Changeset 136124 in webkit

Timestamp:

Nov 29, 2012 5:25:53 AM (11 years ago)

Author:

Simon Hausmann

Message:

[Qt] Implement support for Cocoa based NPAPI plugins on Mac
​https://bugs.webkit.org/show_bug.cgi?id=72358

Patch by Andy Shaw <​andy.shaw@digia.com> on 2012-11-29
Reviewed by Simon Hausmann.

With later versions of Flash they are only Cocoa based which meant that it was not possible to use Flash in a QtWebKit browser.
This makes it possible to also use 64bit based plugins too.

• plugins/PluginPackage.cpp:

(WebCore::PluginPackage::initializeBrowserFuncs):
(WebCore):

• plugins/PluginQuirkSet.h:
• plugins/PluginView.cpp:

(WebCore::PluginView::handleEvent):
(WebCore::PluginView::PluginView):
(WebCore):
(WebCore::PluginView::userAgent):

• plugins/PluginView.h:

(WebCore):
(PluginView):

• plugins/mac/PluginPackageMac.cpp:

(WebCore::PluginPackage::determineQuirks):
(WebCore::PluginPackage::fetchInfo):

• plugins/mac/PluginViewMac.mm:

(WebCore):
(WebCore::initializeNPCocoaEvent):
(WebCore::getModifiers):
(WebCore::PluginView::platformStart):

• plugins/npapi.cpp:

(NPN_PopUpContextMenu):

• plugins/npapi.h:

Location:

trunk/Source/WebCore

Files:

• ChangeLog (modified) (1 diff)
• plugins/PluginPackage.cpp (modified) (1 diff)
• plugins/PluginQuirkSet.h (modified) (1 diff)
• plugins/PluginView.cpp (modified) (4 diffs)
• plugins/PluginView.h (modified) (3 diffs)
• plugins/mac/PluginPackageMac.cpp (modified) (2 diffs)
• plugins/mac/PluginViewMac.mm (modified) (23 diffs)
• plugins/npapi.cpp (modified) (1 diff)
• plugins/npapi.h (modified) (1 diff)

trunk/Source/WebCore/ChangeLog

@@ +1 @@
+2012-11-29  Andy Shaw  <andy.shaw@digia.com>
+
+        [Qt] Implement support for Cocoa based NPAPI plugins on Mac
+        https://bugs.webkit.org/show_bug.cgi?id=72358
+
+        Reviewed by Simon Hausmann.
+
+        With later versions of Flash they are only Cocoa based which meant that it was not possible to use Flash in a QtWebKit browser.
+        This makes it possible to also use 64bit based plugins too.  
+
+        * plugins/PluginPackage.cpp:
+        (WebCore::PluginPackage::initializeBrowserFuncs):
+        (WebCore):
+        * plugins/PluginQuirkSet.h:
+        * plugins/PluginView.cpp:
+        (WebCore::PluginView::handleEvent):
+        (WebCore::PluginView::PluginView):
+        (WebCore):
+        (WebCore::PluginView::userAgent):
+        * plugins/PluginView.h:
+        (WebCore):
+        (PluginView):
+        * plugins/mac/PluginPackageMac.cpp:
+        (WebCore::PluginPackage::determineQuirks):
+        (WebCore::PluginPackage::fetchInfo):
+        * plugins/mac/PluginViewMac.mm:
+        (WebCore):
+        (WebCore::initializeNPCocoaEvent):
+        (WebCore::getModifiers):
+        (WebCore::PluginView::platformStart):
+        * plugins/npapi.cpp:
+        (NPN_PopUpContextMenu):
+        * plugins/npapi.h:
+
 2012-11-29  Sheriff Bot  <webkit.review.bot@gmail.com>
 

trunk/Source/WebCore/plugins/PluginPackage.cpp

@@ -331 +331 @@
     m_browserFuncs.setvalueforurl = NPN_SetValueForURL;
     m_browserFuncs.getauthenticationinfo = NPN_GetAuthenticationInfo;
-}
-#endif
+
+    m_browserFuncs.popupcontextmenu = NPN_PopUpContextMenu;
+}
+#endif // ENABLE(NETSCAPE_PLUGIN_API)
 
 #if ENABLE(PLUGIN_PACKAGE_SIMPLE_HASH)

trunk/Source/WebCore/plugins/PluginQuirkSet.h

@@ -49 +49 @@
         PluginQuirkRequiresDefaultScreenDepth = 1 << 13,
         PluginQuirkDontCallSetWindowMoreThanOnce = 1 << 14,
-        PluginQuirkIgnoreRightClickInWindowlessMode = 1 << 15
+        PluginQuirkIgnoreRightClickInWindowlessMode = 1 << 15,
+        PluginQuirkWantsChromeUserAgent = 1 << 16
     };
 

trunk/Source/WebCore/plugins/PluginView.cpp

@@ -63 +63 @@
 #include "SecurityOrigin.h"
 #include "Settings.h"
+#include "WheelEvent.h"
 #include "npruntime_impl.h"
 #include <wtf/ASCIICType.h>
@@ -170 +171 @@
     else if (event->isKeyboardEvent())
         handleKeyboardEvent(static_cast<KeyboardEvent*>(event));
+#if defined(XP_MACOSX)
+    else if (event->type() == eventNames().mousewheelEvent)
+        handleWheelEvent(static_cast<WheelEvent*>(event));
+#endif
     else if (event->type() == eventNames().contextmenuEvent)
         event->setDefaultHandled(); // We don't know if the plug-in has handled mousedown event by displaying a context menu, so we never want WebKit to show a default one.
@@ -833 +838 @@
 #if defined(XP_MACOSX)
     , m_isWindowed(false)
+    , m_updatedCocoaTextInputRequested(false)
+    , m_keyDownSent(false)
+    , m_disregardKeyUpCounter(0)
 #else
     , m_isWindowed(true)
@@ -1256 +1264 @@
         " en-US; rv:1.8.1) Gecko/20061010 Firefox/2.0";
 
+static const char* const ChromeUserAgent = "Mozilla/5.0 ("
+#if defined(XP_MACOSX)
+    "Macintosh; U; Intel Mac OS X;"
+#elif defined(XP_WIN)
+    "Windows; U; Windows NT 5.1;"
+#elif defined(XP_UNIX)
+    // The Gtk port uses X11 plugins in Mac.
+#if OS(DARWIN) && PLATFORM(GTK)
+    "X11; U; Intel Mac OS X;"
+#else
+    "X11; U; Linux i686;"
+#endif
+#endif
+    " AppleWebKit/534.34 (KHTML, like Gecko) Chrome/19.0.1055.1 Safari/534.34";
+
 const char* PluginView::userAgent()
 {
     if (m_plugin->quirks().contains(PluginQuirkWantsMozillaUserAgent))
         return MozillaUserAgent;
-
+    else if (m_plugin->quirks().contains(PluginQuirkWantsChromeUserAgent))
+        return ChromeUserAgent;
     if (m_userAgent.isNull())
         m_userAgent = m_parentFrame->loader()->userAgent(m_url).utf8();

trunk/Source/WebCore/plugins/PluginView.h

@@ -99 +99 @@
     class ResourceError;
     class ResourceResponse;
+    class WheelEvent;
 
     enum PluginStatus {
@@ -230 +231 @@
         const KURL& url() const { return m_url; }
 
+#if defined(XP_MACOSX) && ENABLE(NETSCAPE_PLUGIN_API)
+        bool popUpContextMenu(NPMenu*);
+#endif
+
 #if OS(WINDOWS) && ENABLE(NETSCAPE_PLUGIN_API)
         static LRESULT CALLBACK PluginViewWndProc(HWND, UINT, WPARAM, LPARAM);
@@ -323 +328 @@
         bool dispatchNPEvent(NPEvent&);
 #endif // ENABLE(NETSCAPE_PLUGIN_API)
+#endif
+#if defined(XP_MACOSX) && ENABLE(NETSCAPE_PLUGIN_API)
+        int16_t dispatchNPCocoaEvent(NPCocoaEvent&);
+        bool m_updatedCocoaTextInputRequested;
+        bool m_keyDownSent;
+        bool m_usePixmap;
+        uint16_t m_disregardKeyUpCounter;
+#endif
+
+#if defined(XP_MACOSX)
+        void handleWheelEvent(WheelEvent*);
 #endif
         void updatePluginWidget();

trunk/Source/WebCore/plugins/mac/PluginPackageMac.cpp

@@ -58 +58 @@
 
     if (mimeType == "application/x-shockwave-flash") {
-        // The flash plugin only requests windowless plugins if we return a mozilla user agent
-        m_quirks.add(PluginQuirkWantsMozillaUserAgent);
+        m_quirks.add(PluginQuirkWantsChromeUserAgent);
         m_quirks.add(PluginQuirkThrottleInvalidate);
         m_quirks.add(PluginQuirkThrottleWMUserPlusOneMessages);
@@ -197 +196 @@
             String description = (CFStringRef)CFDictionaryGetValue(extensionsDict.get(), CFSTR("WebPluginTypeDescription"));
             m_mimeToDescriptions.set(mimeType, description);
+            determineQuirks(mimeType);
         }
 

trunk/Source/WebCore/plugins/mac/PluginViewMac.mm

@@ -59 +59 @@
 #include "ScriptController.h"
 #include "Settings.h"
+#include "WheelEvent.h"
 #include "npruntime_impl.h"
 #include "runtime_root.h"
@@ -76 +77 @@
 #include <QKeyEvent>
 #include <QPainter>
+#include <QDateTime>
+#include <QPixmap>
 #include "QWebPageClient.h"
 QT_BEGIN_NAMESPACE
 extern Q_GUI_EXPORT OSWindowRef qt_mac_window_for(const QWidget* w);
+extern Q_GUI_EXPORT CGContextRef qt_mac_cg_context(const QPaintDevice *pdev); //qpaintdevice_mac.cpp
 QT_END_NAMESPACE
 #endif
@@ -143 +147 @@
 #endif
     return IntPoint();
+}
+
+// --------- Cocoa specific utility functions ----------
+
+static void initializeNPCocoaEvent(NPCocoaEvent* event)
+{
+    memset(event, 0, sizeof(NPCocoaEvent));
+}
+
+static int32_t getModifiers(UIEventWithKeyState *event)
+{
+    int32_t modifiers = 0;
+    if (event->keyCode() == 57) modifiers |= NSAlphaShiftKeyMask;
+    if (event->shiftKey())  modifiers |= NSShiftKeyMask;
+    if (event->ctrlKey())   modifiers |= NSControlKeyMask;
+    if (event->metaKey())   modifiers |= NSCommandKeyMask;
+    if (event->altKey())    modifiers |= NSAlternateKeyMask;
+
+    return modifiers;
 }
 
@@ -180 +203 @@
     if (getValueStatic(NPNVariable(NPNVsupportsCarbonBool + m_eventModel), &eventModelSupported) != NPERR_NO_ERROR
             || !eventModelSupported) {
+#else
+    NPBool eventModelSupported;
+    if (getValueStatic(NPNVariable(NPNVsupportsCocoaBool/* + m_eventModel*/), &eventModelSupported) != NPERR_NO_ERROR
+            || !eventModelSupported) {
 #endif
         m_status = PluginStatusCanNotLoadPlugin;
@@ -185 +212 @@
                 m_plugin->name().utf8().data(), prettyNameForEventModel(m_eventModel));
         return false;
-#ifndef NP_NO_CARBON
-    }
-#endif
+    }
 
 #ifndef NP_NO_QUICKDRAW
@@ -193 +218 @@
     if (getValueStatic(NPNVariable(NPNVsupportsQuickDrawBool + m_drawingModel), &drawingModelSupported) != NPERR_NO_ERROR
             || !drawingModelSupported) {
-#endif
         m_status = PluginStatusCanNotLoadPlugin;
         LOG(Plugins, "Plug-in '%s' uses unsupported drawing model %s",
                 m_plugin->name().utf8().data(), prettyNameForDrawingModel(m_drawingModel));
         return false;
-#ifndef NP_NO_QUICKDRAW
-    }
-#endif
+    }
+#endif
+
+#ifdef NP_NO_QUICKDRAW
+    NPBool drawingModelSupported;
+    if (getValueStatic(NPNVariable(NPNVsupportsCoreGraphicsBool/* + m_drawingModel*/), &drawingModelSupported) != NPERR_NO_ERROR
+            || !drawingModelSupported) {
+        m_status = PluginStatusCanNotLoadPlugin;
+        LOG(Plugins, "Plug-in '%s' uses unsupported drawing model %s",
+                m_plugin->name().utf8().data(), prettyNameForDrawingModel(m_drawingModel));
+        return false;
+    }
+#endif
+
 
 #if PLATFORM(QT)
@@ -216 +251 @@
 
     // Create a fake window relative to which all events will be sent when using offscreen rendering
+#ifndef NP_NO_CARBON
     if (!platformPluginWidget()) {
-#ifndef NP_NO_CARBON
         // Make the default size really big. It is unclear why this is required but with a smaller size, mouse move
         // events don't get processed. Resizing the fake window to flash's size doesn't help.
@@ -224 +259 @@
         // Flash requires the window to be hilited to process mouse move events.
         HiliteWindow(m_fakeWindow, true);
-#endif
-    }
+    }
+#endif
 
     updatePluginWidget();
@@ -232 +267 @@
         setNPWindowIfNeeded();
 
+#ifndef NP_NO_CARBON
     // TODO: Implement null timer throttling depending on plugin activation
     m_nullEventTimer = adoptPtr(new Timer<PluginView>(this, &PluginView::nullEventTimerFired));
@@ -237 +273 @@
 
     m_lastMousePos.h = m_lastMousePos.v = 0;
+#endif // NP_NO_CARBON
 
     return true;
@@ -277 +314 @@
 #endif
     case NPNVsupportsCocoaBool:
-        *static_cast<NPBool*>(value) = false;
+        *static_cast<NPBool*>(value) = true;
         *result = NPERR_NO_ERROR;
         return true;
@@ -287 +324 @@
         return true;
 
+    case NPNVsupportsAdvancedKeyHandling:
+        *static_cast<NPBool*>(value) = true;
+        *result = NPERR_NO_ERROR;
+        return true;
+
 #ifndef NP_NO_QUICKDRAW
     // QuickDraw is deprecated in 10.5 and not supported on 64-bit
@@ -305 +347 @@
 bool PluginView::platformGetValue(NPNVariable variable, void* value, NPError* error)
 {
+    // In WebKit2, this is set if the plugin queries it's availiablity and
+    // no key down events have already been sent.
+    if (variable == NPNVsupportsUpdatedCocoaTextInputBool) {
+        if (m_keyDownSent && !m_updatedCocoaTextInputRequested) {
+            *static_cast<NPBool*>(value) = false;
+            *error = NPERR_NO_ERROR;
+        }
+        else {
+            *static_cast<NPBool*>(value) = true;
+            *error = NPERR_NO_ERROR;
+            m_updatedCocoaTextInputRequested = true;
+        }
+        return true;
+    }
     return false;
 }
@@ -343 +399 @@
     if (!focused) {
         Widget::setFocus(focused);
-        return;
+        if (m_eventModel != NPEventModelCocoa)
+            return;
     }
 
     if (platformPluginWidget())
 #if PLATFORM(QT)
-       static_cast<QWidget*>(platformPluginWidget())->setFocus(Qt::OtherFocusReason);
+        static_cast<QWidget*>(platformPluginWidget())->setFocus(Qt::OtherFocusReason);
 #else
         platformPluginWidget()->SetFocus();
 #endif
-   else
-       Widget::setFocus(focused);
-
+    else
+        Widget::setFocus(focused);
+
+
+#ifndef NP_NO_CARBON
     // TODO: Also handle and pass on blur events (focus lost)
-
-#ifndef NP_NO_CARBON
     EventRecord record;
     record.what = NPEventType_GetFocusEvent;
@@ -368 +425 @@
         LOG(Events, "PluginView::setFocus(%d): Focus event not accepted", focused);
 #endif
+    {
+        NPCocoaEvent cocoaEvent;
+        initializeNPCocoaEvent(&cocoaEvent);
+        cocoaEvent.type = NPCocoaEventFocusChanged;
+        NPBool focus = focused;
+        cocoaEvent.data.focus.hasFocus = focus;
+
+        if(!dispatchNPCocoaEvent(cocoaEvent)) {
+            LOG(Events, "PluginView::setFocus(): Focus event %d not accepted", cocoaEvent.type);
+        }
+    }
 }
 
@@ -400 +468 @@
     }
 
-    if (!newContextRef || !newWindowRef)
-        return;
+    if (!newContextRef || !newWindowRef) {
+        if (!m_usePixmap)
+            return;
+    }
 
     m_npWindow.window = (void*)&m_npCgContext;
@@ -475 +545 @@
     if (context->paintingDisabled())
         return;
-
+#if PLATFORM(QT)
+    QPainter* p = context->platformContext();
+    CGContextRef cgContext = qt_mac_cg_context(p->device());
+#else
+    CGContextRef cgContext = m_npCgContext.context;
+#endif
     setNPWindowIfNeeded();
-
-    CGContextRef cgContext = m_npCgContext.context;
-    if (!cgContext)
-        return;
+    if (!cgContext) {
+        cgContext = m_contextRef;
+        if (!cgContext)
+            return;
+        else {
+            m_usePixmap = true;
+            setNPWindowIfNeeded();
+        }
+    } else
+        m_usePixmap = false;
+
+    bool oldUsePixmap = m_usePixmap;
+    if (m_isTransparent && !m_usePixmap) {
+        if (m_pixmap.isNull())
+            m_pixmap = QPixmap(frameRect().size());
+        m_usePixmap = true;
+        setNPWindowIfNeeded();
+        cgContext = qt_mac_cg_context(&m_pixmap);
+    }
 
     CGContextSaveGState(cgContext);
@@ -499 +589 @@
     CGContextClipToRect(cgContext, r);
 
-    if (!platformPluginWidget() && m_isTransparent) { // clean the pixmap in transparent mode
+    if (!platformPluginWidget() || m_isTransparent) { // clean the pixmap in transparent mode
 #if PLATFORM(QT)
         QPainter painter(&m_pixmap);
@@ -508 +598 @@
 
 #ifndef NP_NO_CARBON
-    EventRecord event;
-    event.what = updateEvt;
-    event.message = (long unsigned int)m_npCgContext.window;
-    event.when = TickCount();
-    event.where.h = 0;
-    event.where.v = 0;
-    event.modifiers = GetCurrentKeyModifiers();
-
-    if (!dispatchNPEvent(event))
-        LOG(Events, "PluginView::paint(): Paint event not accepted");
-#endif
-
-    CGContextRestoreGState(cgContext);
-
-    if (!platformPluginWidget()) {
+    if (m_eventModel != NPEventModelCocoa) {
+        EventRecord event;
+        event.what = updateEvt;
+        event.message = (long unsigned int)m_npCgContext.window;
+        event.when = TickCount();
+        event.where.h = 0;
+        event.where.v = 0;
+        event.modifiers = GetCurrentKeyModifiers();
+
+        if (!dispatchNPEvent(event))
+            LOG(Events, "PluginView::paint(): Paint event not accepted");
+    } else
+#endif
+    {
+        NPCocoaEvent cocoaEvent;
+        initializeNPCocoaEvent(&cocoaEvent);
+        cocoaEvent.type = NPCocoaEventDrawRect;
+        cocoaEvent.data.draw.x = m_usePixmap ? 0 : r.origin.x;
+        cocoaEvent.data.draw.y = m_usePixmap ? 0 : r.origin.y;
+        cocoaEvent.data.draw.width = m_usePixmap ? m_pixmap.width() : r.size.width;
+        cocoaEvent.data.draw.height = m_usePixmap ? m_pixmap.height() : r.size.height;
+        cocoaEvent.data.draw.context = cgContext;
+        
+        if(!dispatchNPCocoaEvent(cocoaEvent))
+            LOG(Events, "PluginView::paint(): Paint event type %d not accepted", cocoaEvent.type);
+    }
+    
+    if (!platformPluginWidget() || m_isTransparent) {
 #if PLATFORM(QT)
         QPainter* painter = context->platformContext();
-        painter->drawPixmap(targetRect.x(), targetRect.y(), m_pixmap, 
+        painter->drawPixmap(targetRect.x(), targetRect.y(), m_pixmap,
                             targetRect.x() - frameRect().x(), targetRect.y() - frameRect().y(), targetRect.width(), targetRect.height());
 #endif
     }
-}
-
+    CGContextRestoreGState(cgContext);
+    if (oldUsePixmap != m_usePixmap) {
+        m_usePixmap = oldUsePixmap;
+        m_pixmap = QPixmap();
+    }    
+}
+
+bool PluginView::popUpContextMenu(NPMenu *menu)
+{
+    NSEvent* currentEvent = [NSApp currentEvent];
+    
+    // NPN_PopUpContextMenu must be called from within the plug-in's NPP_HandleEvent.
+    if (!currentEvent)
+        return NPERR_GENERIC_ERROR;
+    
+    NSWindow* window = [currentEvent window];
+    NSView* view = [window contentView];
+    [NSMenu popUpContextMenu:(NSMenu*)menu withEvent:currentEvent forView:view];
+    return true;
+}
+    
 void PluginView::invalidateRect(const IntRect& rect)
 {
-    if (platformPluginWidget())
+    if (platformPluginWidget() && m_isTransparent)
 #if PLATFORM(QT)
         static_cast<QWidget*>(platformPluginWidget())->update(convertToContainingWindow(rect));
@@ -539 +661 @@
         platformPluginWidget()->RefreshRect(convertToContainingWindow(rect));
 #endif
-    else
-        invalidateWindowlessPluginRect(rect);
+    invalidateWindowlessPluginRect(rect);
 }
 
@@ -562 +683 @@
 
 // ----------------- Event handling --------------------
+void PluginView::handleWheelEvent(WheelEvent *event)
+{
+    if (!m_isStarted || m_eventModel != NPEventModelCocoa)
+        return;
+    
+    NPCocoaEvent cocoaEvent;
+    initializeNPCocoaEvent(&cocoaEvent);
+    
+    NSEvent *currentEvent = [NSApp currentEvent];
+    
+    cocoaEvent.type = NPCocoaEventScrollWheel;
+    
+    cocoaEvent.data.mouse.pluginX = event->layerX() - m_npWindow.x + m_windowRect.x() - m_element->offsetLeft();
+    cocoaEvent.data.mouse.pluginY = event->layerY() - m_npWindow.y + m_windowRect.y() - m_element->offsetTop();
+    cocoaEvent.data.mouse.deltaX = [currentEvent deltaX];
+    cocoaEvent.data.mouse.deltaY = [currentEvent deltaY];
+    cocoaEvent.data.mouse.deltaZ = [currentEvent deltaZ];
+    cocoaEvent.data.mouse.modifierFlags = getModifiers(event);
+    
+    if(!dispatchNPCocoaEvent(cocoaEvent)) {
+        LOG(Events, "PluginView::handleMouseEvent(): Wheel event type %d at %d,%d not accepted", cocoaEvent.type
+            cocoaEvent.data.mouse.x, cocoaEvent.data.mouse.y);
+    }
+    event->setDefaultHandled();
+}
 
 void PluginView::handleMouseEvent(MouseEvent* event)
@@ -567 +713 @@
     if (!m_isStarted)
         return;
-
-#ifndef NP_NO_CARBON
-    EventRecord record;
-
-    if (event->type() == eventNames().mousemoveEvent) {
-        // Mouse movement is handled by null timer events
-        m_lastMousePos = mousePosForPlugin(event);
-        return;
-    } else if (event->type() == eventNames().mouseoverEvent) {
-        record.what = NPEventType_AdjustCursorEvent;
-    } else if (event->type() == eventNames().mouseoutEvent) {
-        record.what = NPEventType_AdjustCursorEvent;
-    } else if (event->type() == eventNames().mousedownEvent) {
-        record.what = mouseDown;
-        // The plugin needs focus to receive keyboard events
-        if (Page* page = m_parentFrame->page())
-            page->focusController()->setFocusedFrame(m_parentFrame);
-        m_parentFrame->document()->setFocusedNode(m_element);
-    } else if (event->type() == eventNames().mouseupEvent) {
-        record.what = mouseUp;
-    } else {
-        return;
-    }
-    record.where = mousePosForPlugin(event);
-    record.modifiers = modifiersForEvent(event);
-
-    if (!event->buttonDown())
-        record.modifiers |= btnState;
-
-    if (event->button() == 2)
-        record.modifiers |= controlKey;
-
-    if (!dispatchNPEvent(record)) {
-        if (record.what == NPEventType_AdjustCursorEvent)
-            return; // Signals that the plugin wants a normal cursor
-
-        LOG(Events, "PluginView::handleMouseEvent(): Mouse event type %d at %d,%d not accepted",
+    
+#ifndef NP_NO_CARBON
+    if (m_eventModel != NPEventModelCocoa) {
+        EventRecord record;
+        
+        if (event->type() == eventNames().mousemoveEvent) {
+            // Mouse movement is handled by null timer events
+            m_lastMousePos = mousePosForPlugin(event);
+            return;
+        } else if (event->type() == eventNames().mouseoverEvent) {
+            record.what = NPEventType_AdjustCursorEvent;
+        } else if (event->type() == eventNames().mouseoutEvent) {
+            record.what = NPEventType_AdjustCursorEvent;
+        } else if (event->type() == eventNames().mousedownEvent) {
+            record.what = mouseDown;
+            // The plugin needs focus to receive keyboard events
+            if (Page* page = m_parentFrame->page())
+                page->focusController()->setFocusedFrame(m_parentFrame);
+            m_parentFrame->document()->setFocusedNode(m_element);
+        } else if (event->type() == eventNames().mouseupEvent) {
+            record.what = mouseUp;
+        } else {
+            return;
+        }
+        record.where = mousePosForPlugin(event);
+        record.modifiers = modifiersForEvent(event);
+        
+        if (!event->buttonDown())
+            record.modifiers |= btnState;
+        
+        if (event->button() == 2)
+            record.modifiers |= controlKey;
+        
+        if (!dispatchNPEvent(record)) {
+            if (record.what == NPEventType_AdjustCursorEvent)
+                return; // Signals that the plugin wants a normal cursor
+            
+            LOG(Events, "PluginView::handleMouseEvent(): Mouse event type %d at %d,%d not accepted",
                 record.what, record.where.h, record.where.v);
-    } else {
+        } else {
+            event->setDefaultHandled();
+        }
+    } else
+#endif
+    {
+        NPCocoaEventType eventType;
+        int32_t buttonNumber = 0;
+        int32_t clickCount = 0;
+        NSEvent *currentEvent = [NSApp currentEvent];
+        
+        NSEventType type = [currentEvent type];
+        
+        switch (type) {
+            case NSLeftMouseDown:
+            case NSRightMouseDown:
+            case NSOtherMouseDown:
+                buttonNumber = [currentEvent buttonNumber];
+                clickCount = [currentEvent clickCount];
+                eventType = NPCocoaEventMouseDown;
+                // The plugin needs focus to receive keyboard events
+                if (Page* page = m_parentFrame->page())
+                    page->focusController()->setFocusedFrame(m_parentFrame);
+                m_parentFrame->document()->setFocusedNode(m_element);
+                break;
+                
+            case NSLeftMouseUp:
+            case NSRightMouseUp:
+            case NSOtherMouseUp:
+                buttonNumber = [currentEvent buttonNumber];
+                clickCount = [currentEvent clickCount];
+                eventType = NPCocoaEventMouseUp;
+                break;
+                
+            case NSMouseMoved:
+                eventType = NPCocoaEventMouseMoved;
+                break;
+                
+            case NSLeftMouseDragged:
+            case NSRightMouseDragged:
+            case NSOtherMouseDragged:
+                buttonNumber = [currentEvent buttonNumber];
+                eventType = NPCocoaEventMouseDragged;
+                break;
+                
+            case NSMouseEntered:
+                eventType = NPCocoaEventMouseEntered;
+                break;
+                
+            case NSMouseExited:
+                eventType = NPCocoaEventMouseExited;
+            default:
+                return;
+        }
+        
+        NPCocoaEvent cocoaEvent;
+        initializeNPCocoaEvent(&cocoaEvent);
+        
+        cocoaEvent.type = eventType;
+        if (!(NPCocoaEventMouseEntered == eventType || NPCocoaEventMouseExited == eventType)) {
+            cocoaEvent.data.mouse.buttonNumber = buttonNumber;
+            cocoaEvent.data.mouse.clickCount = clickCount;
+        }
+        
+        cocoaEvent.data.mouse.pluginX = event->layerX() - m_npWindow.x + m_windowRect.x() - m_element->offsetLeft();
+        cocoaEvent.data.mouse.pluginY = event->layerY() - m_npWindow.y + m_windowRect.y() - m_element->offsetTop();
+        cocoaEvent.data.mouse.deltaX = [currentEvent deltaX];
+        cocoaEvent.data.mouse.deltaY = [currentEvent deltaY];
+        cocoaEvent.data.mouse.deltaZ = [currentEvent deltaZ];
+        cocoaEvent.data.mouse.modifierFlags = getModifiers(event);
+        
+        int16_t response = dispatchNPCocoaEvent(cocoaEvent);
+        if(response = kNPEventNotHandled) {
+            LOG(Events, "PluginView::handleMouseEvent(): Mouse event type %d at %d,%d not accepted", cocoaEvent.type
+                cocoaEvent.data.mouse.x, cocoaEvent.data.mouse.y);
+        }
+        
+        // Safari policy is to return true for all mouse events, because some plugins
+        // return false even if they have handled the event.
         event->setDefaultHandled();
     }
-#endif
-}
-
+}
+    
 void PluginView::handleKeyboardEvent(KeyboardEvent* event)
 {
     if (!m_isStarted)
         return;
-
     LOG(Plugins, "PluginView::handleKeyboardEvent() ----------------- ");
-
+    
     LOG(Plugins, "PV::hKE(): KE.keyCode: 0x%02X, KE.charCode: %d",
-            event->keyCode(), event->charCode());
-
-#ifndef NP_NO_CARBON
-    EventRecord record;
-
-    if (event->type() == eventNames().keydownEvent) {
-        // This event is the result of a PlatformEvent::KeyDown which
-        // was disambiguated into a PlatformKeyboardEvent::RawKeyDown. Since
-        // we don't have access to the text here, we return, and wait for the
-        // corresponding event based on PlatformKeyboardEvent::Char.
-        return;
-    } else if (event->type() == eventNames().keypressEvent) {
-        // Which would be this one. This event was disambiguated from the same
-        // PlatformEvent::KeyDown, but to a PlatformEvent::Char,
-        // which retains the text from the original event. So, we can safely pass
-        // on the event as a key-down event to the plugin.
-        record.what = keyDown;
-    } else if (event->type() == eventNames().keyupEvent) {
-        // PlatformEvent::KeyUp events always have the text, so nothing
-        // fancy here.
-        record.what = keyUp;
-    } else {
-        return;
-    }
-
-    const PlatformKeyboardEvent* platformEvent = event->keyEvent();
-    int keyCode = platformEvent->nativeVirtualKeyCode();
-
-    const String text = platformEvent->text();
-    if (text.length() < 1) {
-        event->setDefaultHandled();
-        return;
-    }
-
-    WTF::RetainPtr<CFStringRef> cfText(WTF::AdoptCF, text.createCFString());
-
-    LOG(Plugins, "PV::hKE(): PKE.text: %s, PKE.unmodifiedText: %s, PKE.keyIdentifier: %s",
+        event->keyCode(), event->charCode());
+    
+#ifndef NP_NO_CARBON
+    if (m_eventModel != NPEventModelCocoa) {
+        EventRecord record;
+        if (event->type() == eventNames().keydownEvent) {
+            // This event is the result of a PlatformKeyboardEvent::KeyDown which
+            // was disambiguated into a PlatformKeyboardEvent::RawKeyDown. Since
+            // we don't have access to the text here, we return, and wait for the
+            // corresponding event based on PlatformKeyboardEvent::Char.
+            return;
+        } else if (event->type() == eventNames().keypressEvent) {
+            // Which would be this one. This event was disambiguated from the same
+            // PlatformKeyboardEvent::KeyDown, but to a PlatformKeyboardEvent::Char,
+            // which retains the text from the original event. So, we can safely pass
+            // on the event as a key-down event to the plugin.
+            record.what = keyDown;
+        } else if (event->type() == eventNames().keyupEvent) {
+            // PlatformKeyboardEvent::KeyUp events always have the text, so nothing
+            // fancy here.
+            record.what = keyUp;
+        } else {
+            return;
+        }
+        
+        const PlatformKeyboardEvent* platformEvent = event->keyEvent();
+        int keyCode = platformEvent->nativeVirtualKeyCode();
+        
+        const String text = platformEvent->text();
+        if (text.length() < 1) {
+            event->setDefaultHandled();
+            return;
+        }
+        
+        WTF::RetainPtr<CFStringRef> cfText(WTF::AdoptCF, text.createCFString());
+        
+        LOG(Plugins, "PV::hKE(): PKE.text: %s, PKE.unmodifiedText: %s, PKE.keyIdentifier: %s",
             text.ascii().data(), platformEvent->unmodifiedText().ascii().data(),
             platformEvent->keyIdentifier().ascii().data());
-
-    char charCodes[2] = { 0, 0 };
-    if (!CFStringGetCString(cfText.get(), charCodes, 2, CFStringGetSystemEncoding())) {
-        LOG_ERROR("Could not resolve character code using system encoding.");
-        event->setDefaultHandled();
-        return;
-    }
-
-    record.where = globalMousePosForPlugin();
-    record.modifiers = modifiersForEvent(event);
-    record.message = ((keyCode & 0xFF) << 8) | (charCodes[0] & 0xFF);
-    record.when = TickCount();
-
-    LOG(Plugins, "PV::hKE(): record.modifiers: %d", record.modifiers);
-
+        
+        char charCodes[2] = { 0, 0 };
+        if (!CFStringGetCString(cfText.get(), charCodes, 2, CFStringGetSystemEncoding())) {
+            LOG_ERROR("Could not resolve character code using system encoding.");
+            event->setDefaultHandled();
+            return;
+        }
+        
+        record.where = globalMousePosForPlugin();
+        record.modifiers = modifiersForEvent(event);
+        record.message = ((keyCode & 0xFF) << 8) | (charCodes[0] & 0xFF);
+        record.when = TickCount();
+        
+        LOG(Plugins, "PV::hKE(): record.modifiers: %d", record.modifiers);
+        
 #if PLATFORM(QT)
-    LOG(Plugins, "PV::hKE(): PKE.qtEvent()->nativeVirtualKey: 0x%02X, charCode: %d",
-               keyCode, int(uchar(charCodes[0])));
-#endif
-
-    if (!dispatchNPEvent(record))
-        LOG(Events, "PluginView::handleKeyboardEvent(): Keyboard event type %d not accepted", record.what);
-    else
-        event->setDefaultHandled();
-#endif
-}
-
+        LOG(Plugins, "PV::hKE(): PKE.qtEvent()->nativeVirtualKey: 0x%02X, charCode: %d",
+            keyCode, int(uchar(charCodes[0])));
+#endif
+        
+        if (!dispatchNPEvent(record))
+            LOG(Events, "PluginView::handleKeyboardEvent(): Keyboard event type %d not accepted", record.what);
+        else
+            event->setDefaultHandled();
+    } else
+#endif
+    {
+        NSEvent *currentEvent = [NSApp currentEvent];
+        NPCocoaEventType eventType;
+        NSEventType type = [currentEvent type];
+        
+        switch (type) {
+            case NSKeyDown:
+                eventType = NPCocoaEventKeyDown;
+                m_keyDownSent = true;
+                break;
+            case NSKeyUp:
+                if (m_disregardKeyUpCounter > 0) {
+                    m_disregardKeyUpCounter--;
+                    event->setDefaultHandled();
+                    return;
+                }
+                eventType = NPCocoaEventKeyUp;
+                break;
+            case NSFlagsChanged:
+                eventType = NPCocoaEventFlagsChanged;
+                break;
+            default:
+                return;
+        }
+        
+        NPCocoaEvent cocoaEvent;
+        initializeNPCocoaEvent(&cocoaEvent);
+        cocoaEvent.type = eventType;
+        if (eventType != NPCocoaEventFlagsChanged) {
+            NSString *characters = [currentEvent characters];
+            NSString *charactersIgnoringModifiers = [currentEvent charactersIgnoringModifiers];
+            cocoaEvent.data.key.characters = reinterpret_cast<NPNSString*>(characters);
+            cocoaEvent.data.key.charactersIgnoringModifiers = reinterpret_cast<NPNSString*>(charactersIgnoringModifiers);
+            cocoaEvent.data.key.isARepeat = [currentEvent isARepeat];
+            cocoaEvent.data.key.keyCode = [currentEvent keyCode];
+            cocoaEvent.data.key.modifierFlags = getModifiers(event);
+        }
+        
+        int16_t response = dispatchNPCocoaEvent(cocoaEvent);
+        if(response == kNPEventNotHandled) {
+            LOG(Events, "PluginView::handleKeyboardEvent(): Keyboard event type %d not accepted", cocoaEvent.type);
+        } else if (response == kNPEventStartIME) {
+            // increment counter and resend as a text input
+            m_disregardKeyUpCounter++;
+            NPCocoaEvent textEvent;
+            initializeNPCocoaEvent(&textEvent);
+            textEvent.type = NPCocoaEventTextInput;
+            textEvent.data.text.text = reinterpret_cast<NPNSString*>([currentEvent characters]);
+            response = dispatchNPCocoaEvent(textEvent);
+            if(response == kNPEventNotHandled)
+                LOG(Events, "PluginView::handleKeyboardEvent(): Keyboard event type %d not accepted", cocoaEvent.type);
+        }
+        
+        // All keyboard events need to be handled to prevent them falling
+        // through to the page, unless they are Meta key events, in which
+        // case they are, unless they are Cmd+a. From WebKit2, possibly
+        // not the most elegant piece of key handling code.....
+        if (event->metaKey()) {
+            if (cocoaEvent.data.key.keyCode == 0)
+                event->setDefaultHandled();
+        } else {
+            // else ignore, it's a Meta Key event for the browser.
+            event->setDefaultHandled();
+        }
+    }
+}
+    
 #ifndef NP_NO_CARBON
 void PluginView::nullEventTimerFired(Timer<PluginView>*)
@@ -783 +1072 @@
 #endif
 
+
+int16_t PluginView::dispatchNPCocoaEvent(NPCocoaEvent& cocoaEvent)
+{
+    PluginView::setCurrentPluginView(this);
+    JSC::JSLock::DropAllLocks dropAllLocks(JSDOMWindowBase::commonJSGlobalData());
+    setCallingPlugin(true);
+
+    int16_t response = m_plugin->pluginFuncs()->event(m_instance, &cocoaEvent);
+
+    setCallingPlugin(false);
+    PluginView::setCurrentPluginView(0);
+
+    return response;
+}
+
 // ------------------- Miscellaneous  ------------------
 

trunk/Source/WebCore/plugins/npapi.cpp

@@ -200 +200 @@
     return pluginViewForInstance(instance)->getAuthenticationInfo(protocol, host, port, scheme, realm, username, ulen, password, plen);
 }
+
+NPError NPN_PopUpContextMenu(NPP instance, NPMenu* menu)
+{
+#if PLATFORM(QT) && defined(XP_MACOSX)
+    PluginView* plugin = pluginViewForInstance(instance);
+    plugin->popUpContextMenu(menu);
+    return NPERR_NO_ERROR;
+#else
+    return NPERR_NO_ERROR;
+#endif // PLATFORM(QT) && defined(XP_MACOSX)
+}

trunk/Source/WebCore/plugins/npapi.h

@@ -416 +416 @@
   NPNVSupportsWindowless = 17,
 
-  NPNVprivateModeBool = 18
+  NPNVprivateModeBool = 18,
+
+  NPNVsupportsAdvancedKeyHandling = 21
 
 #if defined(XP_MACOSX)