#ifndef PluginView_h
#define PluginView_h
#include "FrameLoadRequest.h"
#include "HaltablePlugin.h"
#include "IntRect.h"
#include "MediaCanStartListener.h"
#include "PluginStream.h"
#include "ResourceRequest.h"
#include "Timer.h"
#include "Widget.h"
#include "npruntime_internal.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 OS(WINDOWS) && (PLATFORM(QT) || PLATFORM(WX))
typedef struct HWND__* HWND;
typedef HWND PlatformPluginWidget;
#else
typedef PlatformWidget PlatformPluginWidget;
#if defined(XP_MACOSX) && PLATFORM(QT)
#include <QPixmap>
#endif
#endif
namespace JSC {
namespace Bindings {
class Instance;
}
}
namespace WebCore {
class Element;
class Frame;
class Image;
class KeyboardEvent;
class MouseEvent;
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 Widget, private PluginStreamClient, 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(); }
NPP instance() const { return m_instance; }
void setNPWindowRect(const IntRect&);
static PluginView* currentPluginView();
PassRefPtr<JSC::Bindings::Instance> bindingInstance();
PluginStatus status() const { return m_status; }
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);
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);
#endif
NPError setValue(NPPVariable variable, void* value);
void invalidateRect(NPRect*);
void invalidateRegion(NPRegion);
void forceRedraw();
void pushPopupsEnabledState(bool state);
void popPopupsEnabledState();
virtual void invalidateRect(const IntRect&);
bool arePopupsAllowed() const;
void setJavaScriptPaused(bool);
void privateBrowsingStateChanged(bool);
void disconnectStream(PluginStream*);
void streamDidFinishLoading(PluginStream* stream) { disconnectStream(stream); }
virtual void setFrameRect(const IntRect&);
virtual void frameRectsChanged();
virtual void setFocus(bool);
virtual void show();
virtual void hide();
virtual void paint(GraphicsContext*, const IntRect&);
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
void didReceiveResponse(const ResourceResponse&);
void didReceiveData(const char*, int);
void didFinishLoading();
void didFail(const ResourceError&);
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();
bool start();
#if ENABLE(NETSCAPE_PLUGIN_API)
static void keepAlive(NPP);
#endif
void keepAlive();
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*);
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);
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
static bool platformGetValueStatic(NPNVariable variable, void* value, NPError* result);
bool platformGetValue(NPNVariable variable, void* value, NPError* result);
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
bool dispatchNPEvent(NPEvent&);
#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
int m_mode;
int m_paramCount;
char** m_paramNames;
char** m_paramValues;
String m_pluginsPage;
String m_mimeType;
WTF::CString m_userAgent;
NPP m_instance;
NPP_t m_instanceStruct;
NPWindow m_npWindow;
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
#if ((PLATFORM(QT) || PLATFORM(WX)) && OS(WINDOWS)) || defined(XP_MACOSX)
PlatformPluginWidget m_window;
public:
PlatformPluginWidget platformPluginWidget() const { return m_window; }
void setPlatformPluginWidget(PlatformPluginWidget widget) { m_window = widget; }
#else
public:
void setPlatformPluginWidget(PlatformPluginWidget widget) { setPlatformWidget(widget); }
PlatformPluginWidget platformPluginWidget() const { return platformWidget(); }
#endif
private:
#if defined(XP_UNIX) || OS(SYMBIAN)
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
IntRect m_clipRect; IntRect m_windowRect;
bool m_loadManually;
RefPtr<PluginStream> m_manualStream;
bool m_isJavaScriptPaused;
bool m_isHalted;
bool m_hasBeenHalted;
bool m_haveCalledSetWindow;
static PluginView* s_currentPluginView;
};
}
#endif