diff options
Diffstat (limited to 'Source/WebCore/plugins/PluginView.h')
| -rw-r--r-- | Source/WebCore/plugins/PluginView.h | 503 |
1 files changed, 503 insertions, 0 deletions
diff --git a/Source/WebCore/plugins/PluginView.h b/Source/WebCore/plugins/PluginView.h new file mode 100644 index 0000000..a58d217 --- /dev/null +++ b/Source/WebCore/plugins/PluginView.h @@ -0,0 +1,503 @@ +/* + * Copyright (C) 2006, 2007, 2008, 2009, 2010 Apple Inc. All rights reserved. + * Copyright (C) 2008 Collabora Ltd. All rights reserved. + * Copyright (C) 2009 Girish Ramakrishnan <girish@forwardbias.in> + * + * 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 COMPUTER, INC. ``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 COMPUTER, INC. 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. + */ + +#ifndef PluginView_h +#define PluginView_h + +#include "FrameLoadRequest.h" +#include "HaltablePlugin.h" +#include "IntRect.h" +#include "MediaCanStartListener.h" +#include "PluginViewBase.h" +#include "ResourceRequest.h" +#include "Timer.h" +#include <wtf/HashMap.h> +#include <wtf/HashSet.h> +#include <wtf/OwnPtr.h> +#include <wtf/PassRefPtr.h> +#include <wtf/RefPtr.h> +#include <wtf/Vector.h> +#include <wtf/text/CString.h> + +#if ENABLE(NETSCAPE_PLUGIN_API) +#include "PluginStream.h" +#include "npruntime_internal.h" +#endif + +// ANDROID +// TODO: Upstream to webkit.org +#ifdef PLUGIN_SCHEDULE_TIMER +#include "PluginTimer.h" +#endif + +#if OS(WINDOWS) && (PLATFORM(QT) || PLATFORM(WX)) +typedef struct HWND__* HWND; +typedef HWND PlatformPluginWidget; +#elif defined(ANDROID_PLUGINS) +typedef struct PluginWidgetAndroid* PlatformPluginWidget; +#else +typedef PlatformWidget PlatformPluginWidget; +#if defined(XP_MACOSX) && PLATFORM(QT) +#include <QPixmap> +#endif +#endif +#if PLATFORM(QT) +#include <QGraphicsItem> +#include <QImage> +QT_BEGIN_NAMESPACE +class QPainter; +QT_END_NAMESPACE +#endif + +#if USE(JSC) +namespace JSC { + namespace Bindings { + class Instance; + } +} +#endif + +class NPObject; + +namespace WebCore { + class Element; + class Frame; + class Image; + class KeyboardEvent; + class MouseEvent; +#ifdef ANDROID_PLUGINS + class TouchEvent; +#endif + class KURL; +#if OS(WINDOWS) && ENABLE(NETSCAPE_PLUGIN_API) + class PluginMessageThrottlerWin; +#endif + class PluginPackage; + class PluginRequest; + class PluginStream; + class ResourceError; + class ResourceResponse; + + enum PluginStatus { + PluginStatusCanNotFindPlugin, + PluginStatusCanNotLoadPlugin, + PluginStatusLoadedSuccessfully + }; + + class PluginRequest : public Noncopyable { + public: + PluginRequest(const FrameLoadRequest& frameLoadRequest, bool sendNotification, void* notifyData, bool shouldAllowPopups) + : m_frameLoadRequest(frameLoadRequest) + , m_notifyData(notifyData) + , m_sendNotification(sendNotification) + , m_shouldAllowPopups(shouldAllowPopups) { } + public: + const FrameLoadRequest& frameLoadRequest() const { return m_frameLoadRequest; } + void* notifyData() const { return m_notifyData; } + bool sendNotification() const { return m_sendNotification; } + bool shouldAllowPopups() const { return m_shouldAllowPopups; } + private: + FrameLoadRequest m_frameLoadRequest; + void* m_notifyData; + bool m_sendNotification; + bool m_shouldAllowPopups; + }; + + class PluginManualLoader { + public: + virtual ~PluginManualLoader() {} + virtual void didReceiveResponse(const ResourceResponse&) = 0; + virtual void didReceiveData(const char*, int) = 0; + virtual void didFinishLoading() = 0; + virtual void didFail(const ResourceError&) = 0; + }; + + class PluginView : public PluginViewBase +#if ENABLE(NETSCAPE_PLUGIN_API) + , private PluginStreamClient +#endif + , public PluginManualLoader + , private HaltablePlugin + , private MediaCanStartListener { + public: + static PassRefPtr<PluginView> create(Frame* parentFrame, const IntSize&, Element*, const KURL&, const Vector<String>& paramNames, const Vector<String>& paramValues, const String& mimeType, bool loadManually); + virtual ~PluginView(); + + PluginPackage* plugin() const { return m_plugin.get(); } +#if ENABLE(NETSCAPE_PLUGIN_API) + NPP instance() const { return m_instance; } +#endif + + void setNPWindowRect(const IntRect&); + static PluginView* currentPluginView(); + +#if ENABLE(NETSCAPE_PLUGIN_API) + NPObject* npObject(); +#endif +#if USE(JSC) + PassRefPtr<JSC::Bindings::Instance> bindingInstance(); +#endif + + PluginStatus status() const { return m_status; } + +#if ENABLE(NETSCAPE_PLUGIN_API) + // NPN functions + NPError getURLNotify(const char* url, const char* target, void* notifyData); + NPError getURL(const char* url, const char* target); + NPError postURLNotify(const char* url, const char* target, uint32_t len, const char* but, NPBool file, void* notifyData); + NPError postURL(const char* url, const char* target, uint32_t len, const char* but, NPBool file); + NPError newStream(NPMIMEType type, const char* target, NPStream** stream); + int32_t write(NPStream* stream, int32_t len, void* buffer); + NPError destroyStream(NPStream* stream, NPReason reason); +#endif + const char* userAgent(); +#if ENABLE(NETSCAPE_PLUGIN_API) + static const char* userAgentStatic(); +#endif + void status(const char* message); + +#if ENABLE(NETSCAPE_PLUGIN_API) + NPError getValue(NPNVariable variable, void* value); + static NPError getValueStatic(NPNVariable variable, void* value); + NPError setValue(NPPVariable variable, void* value); + NPError getValueForURL(NPNURLVariable variable, const char* url, char** value, uint32_t* len); + NPError setValueForURL(NPNURLVariable variable, const char* url, const char* value, uint32_t len); + NPError getAuthenticationInfo(const char* protocol, const char* host, int32_t port, const char* scheme, const char* realm, char** username, uint32_t* ulen, char** password, uint32_t* plen); + void invalidateRect(NPRect*); + void invalidateRegion(NPRegion); +#endif + void forceRedraw(); + void pushPopupsEnabledState(bool state); + void popPopupsEnabledState(); +#ifdef PLUGIN_SCHEDULE_TIMER + uint32_t scheduleTimer(NPP, uint32_t interval, bool repeat, + void (*timerFunc)(NPP, uint32_t timerID)); + void unscheduleTimer(NPP, uint32_t timerID); +#endif +#if USE(V8) + NPObject* getNPObject(); +#endif + + virtual void invalidateRect(const IntRect&); + + bool arePopupsAllowed() const; + + void setJavaScriptPaused(bool); + + void privateBrowsingStateChanged(bool); + + void disconnectStream(PluginStream*); + void streamDidFinishLoading(PluginStream* stream) { disconnectStream(stream); } + + // Widget functions + virtual void setFrameRect(const IntRect&); + virtual void frameRectsChanged(); + virtual void setFocus(bool); + virtual void show(); + virtual void hide(); + virtual void paint(GraphicsContext*, const IntRect&); + + // This method is used by plugins on all platforms to obtain a clip rect that includes clips set by WebCore, + // e.g., in overflow:auto sections. The clip rects coordinates are in the containing window's coordinate space. + // This clip includes any clips that the widget itself sets up for its children. + IntRect windowClipRect() const; + + virtual void handleEvent(Event*); + virtual void setParent(ScrollView*); + virtual void setParentVisible(bool); + + virtual bool isPluginView() const { return true; } + + Frame* parentFrame() const { return m_parentFrame.get(); } + + void focusPluginElement(); + + const String& pluginsPage() const { return m_pluginsPage; } + const String& mimeType() const { return m_mimeType; } + const KURL& url() const { return m_url; } + +#if OS(WINDOWS) && ENABLE(NETSCAPE_PLUGIN_API) + static LRESULT CALLBACK PluginViewWndProc(HWND, UINT, WPARAM, LPARAM); + LRESULT wndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam); + WNDPROC pluginWndProc() const { return m_pluginWndProc; } +#endif + + // Used for manual loading + void didReceiveResponse(const ResourceResponse&); + void didReceiveData(const char*, int); + void didFinishLoading(); + void didFail(const ResourceError&); + + // HaltablePlugin + virtual void halt(); + virtual void restart(); + virtual Node* node() const; + virtual bool isWindowed() const { return m_isWindowed; } + virtual String pluginName() const; + + bool isHalted() const { return m_isHalted; } + bool hasBeenHalted() const { return m_hasBeenHalted; } + + static bool isCallingPlugin(); + +#ifdef ANDROID_PLUGINS + Element* getElement() const { return m_element; } +#endif + + bool start(); + +#if ENABLE(NETSCAPE_PLUGIN_API) + static void keepAlive(NPP); +#endif + void keepAlive(); + +#if USE(ACCELERATED_COMPOSITING) +#if defined(XP_UNIX) && ENABLE(NETSCAPE_PLUGIN_API) && PLATFORM(QT) + virtual PlatformLayer* platformLayer() const; +#elif ENABLE(NETSCAPE_PLUGIN_API) && defined(ANDROID_PLUGINS) + virtual PlatformLayer* platformLayer() const; +#else + virtual PlatformLayer* platformLayer() const { return 0; } +#endif +#endif + + private: + PluginView(Frame* parentFrame, const IntSize&, PluginPackage*, Element*, const KURL&, const Vector<String>& paramNames, const Vector<String>& paramValues, const String& mimeType, bool loadManually); + + void setParameters(const Vector<String>& paramNames, const Vector<String>& paramValues); + bool startOrAddToUnstartedList(); + void init(); + bool platformStart(); + void stop(); + void platformDestroy(); + static void setCurrentPluginView(PluginView*); +#if ENABLE(NETSCAPE_PLUGIN_API) + NPError load(const FrameLoadRequest&, bool sendNotification, void* notifyData); + NPError handlePost(const char* url, const char* target, uint32_t len, const char* buf, bool file, void* notifyData, bool sendNotification, bool allowHeaders); + NPError handlePostReadFile(Vector<char>& buffer, uint32_t len, const char* buf); +#endif + static void freeStringArray(char** stringArray, int length); + void setCallingPlugin(bool) const; + + void invalidateWindowlessPluginRect(const IntRect&); + + virtual void mediaCanStart(); + +#if OS(WINDOWS) && ENABLE(NETSCAPE_PLUGIN_API) + void paintWindowedPluginIntoContext(GraphicsContext*, const IntRect&); + static HDC WINAPI hookedBeginPaint(HWND, PAINTSTRUCT*); + static BOOL WINAPI hookedEndPaint(HWND, const PAINTSTRUCT*); +#endif + +#if ENABLE(NETSCAPE_PLUGIN_API) + static bool platformGetValueStatic(NPNVariable variable, void* value, NPError* result); + bool platformGetValue(NPNVariable variable, void* value, NPError* result); +#endif + + RefPtr<Frame> m_parentFrame; + RefPtr<PluginPackage> m_plugin; + Element* m_element; + bool m_isStarted; + KURL m_url; + KURL m_baseURL; + PluginStatus m_status; + Vector<IntRect> m_invalidRects; + + void performRequest(PluginRequest*); + void scheduleRequest(PluginRequest*); + void requestTimerFired(Timer<PluginView>*); + void invalidateTimerFired(Timer<PluginView>*); + Timer<PluginView> m_requestTimer; + Timer<PluginView> m_invalidateTimer; + + void popPopupsStateTimerFired(Timer<PluginView>*); + Timer<PluginView> m_popPopupsStateTimer; + + void lifeSupportTimerFired(Timer<PluginView>*); + Timer<PluginView> m_lifeSupportTimer; + +#ifndef NP_NO_CARBON +#if ENABLE(NETSCAPE_PLUGIN_API) + bool dispatchNPEvent(NPEvent&); +#endif // ENABLE(NETSCAPE_PLUGIN_API) +#endif + void updatePluginWidget(); + void paintMissingPluginIcon(GraphicsContext*, const IntRect&); + + void handleKeyboardEvent(KeyboardEvent*); + void handleMouseEvent(MouseEvent*); +#if defined(XP_UNIX) && ENABLE(NETSCAPE_PLUGIN_API) + void handleFocusInEvent(); + void handleFocusOutEvent(); +#endif + +#if OS(WINDOWS) + void paintIntoTransformedContext(HDC); + PassRefPtr<Image> snapshot(); +#endif + +#ifdef ANDROID_PLUGINS + void handleFocusEvent(bool hasFocus); + void handleTouchEvent(TouchEvent*); + // called at the end of the base constructor + void platformInit(); +#endif +#ifdef PLUGIN_PLATFORM_SETVALUE + // called if the default setValue does not recognize the variable + NPError platformSetValue(NPPVariable variable, void* value); +#endif + + int m_mode; + int m_paramCount; + char** m_paramNames; + char** m_paramValues; + String m_pluginsPage; + + String m_mimeType; + WTF::CString m_userAgent; + +#if ENABLE(NETSCAPE_PLUGIN_API) + NPP m_instance; + NPP_t m_instanceStruct; + NPWindow m_npWindow; +#endif + + Vector<bool, 4> m_popupStateStack; + + HashSet<RefPtr<PluginStream> > m_streams; + Vector<PluginRequest*> m_requests; + + bool m_isWindowed; + bool m_isTransparent; + bool m_haveInitialized; + bool m_isWaitingToStart; + +#if defined(XP_UNIX) + bool m_needsXEmbed; +#endif + +#if OS(WINDOWS) && ENABLE(NETSCAPE_PLUGIN_API) + OwnPtr<PluginMessageThrottlerWin> m_messageThrottler; + WNDPROC m_pluginWndProc; + unsigned m_lastMessage; + bool m_isCallingPluginWndProc; + HDC m_wmPrintHDC; + bool m_haveUpdatedPluginWidget; +#endif + +// ANDROID +// TODO: Upstream to webkit.org +#ifdef PLUGIN_SCHEDULE_TIMER + PluginTimerList m_timerList; +#endif + +#if ((PLATFORM(QT) || PLATFORM(WX)) && OS(WINDOWS)) || defined(XP_MACOSX) + // On Mac OSX and Qt/Windows the plugin does not have its own native widget, + // but is using the containing window as its reference for positioning/painting. + PlatformPluginWidget m_window; +public: + PlatformPluginWidget platformPluginWidget() const { return m_window; } + void setPlatformPluginWidget(PlatformPluginWidget widget) { m_window = widget; } +#elif defined(ANDROID_PLUGINS) +public: + PlatformPluginWidget m_window; + PlatformPluginWidget platformPluginWidget() const { return m_window; } // MANUAL MERGE FIXME +#else +public: + void setPlatformPluginWidget(PlatformPluginWidget widget) { setPlatformWidget(widget); } + PlatformPluginWidget platformPluginWidget() const { return platformWidget(); } +#endif + +private: + +#if defined(XP_UNIX) || OS(SYMBIAN) || defined(ANDROID_PLUGINS) + void setNPWindowIfNeeded(); +#elif defined(XP_MACOSX) + NP_CGContext m_npCgContext; + OwnPtr<Timer<PluginView> > m_nullEventTimer; + NPDrawingModel m_drawingModel; + NPEventModel m_eventModel; + CGContextRef m_contextRef; + WindowRef m_fakeWindow; +#if PLATFORM(QT) + QPixmap m_pixmap; +#endif + + Point m_lastMousePos; + void setNPWindowIfNeeded(); + void nullEventTimerFired(Timer<PluginView>*); + Point globalMousePosForPlugin() const; + Point mousePosForPlugin(MouseEvent* event = 0) const; +#endif + +#if defined(XP_UNIX) && ENABLE(NETSCAPE_PLUGIN_API) + bool m_hasPendingGeometryChange; + Pixmap m_drawable; + Visual* m_visual; + Colormap m_colormap; + Display* m_pluginDisplay; + + void initXEvent(XEvent* event); +#endif + +#if PLATFORM(QT) +#if defined(MOZ_PLATFORM_MAEMO) && (MOZ_PLATFORM_MAEMO >= 5) + QImage m_image; + bool m_renderToImage; + void paintUsingImageSurfaceExtension(QPainter* painter, const IntRect& exposedRect); +#endif +#if defined(XP_UNIX) && ENABLE(NETSCAPE_PLUGIN_API) + void paintUsingXPixmap(QPainter* painter, const QRect &exposedRect); +#if USE(ACCELERATED_COMPOSITING) + OwnPtr<PlatformLayer> m_platformLayer; + friend class PluginGraphicsLayerQt; +#endif // USE(ACCELERATED_COMPOSITING) +#endif +#endif // PLATFORM(QT) + + IntRect m_clipRect; // The clip rect to apply to a windowed plug-in + IntRect m_windowRect; // Our window rect. +#ifdef ANDROID_PLUGINS + IntRect m_pageRect; // The rect in page coordinate system. +#endif + + bool m_loadManually; + RefPtr<PluginStream> m_manualStream; + + bool m_isJavaScriptPaused; + + bool m_isHalted; + bool m_hasBeenHalted; + + bool m_haveCalledSetWindow; + + static PluginView* s_currentPluginView; + }; + +} // namespace WebCore + +#endif |