linux: Adding events to windowless plugins on Linux

webkit/glue/plugins/webplugin_delegate_impl.cc

 // Copyright (c) 2006-2008 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "webkit/glue/plugins/webplugin_delegate_impl.h"
 
 #include <string>
 #include <vector>
 
 #include "base/file_util.h"
 #include "base/iat_patch.h"
 #include "base/lazy_instance.h"
 #include "base/message_loop.h"
 #include "base/stats_counters.h"
 #include "base/string_util.h"
+#include "webkit/api/public/WebInputEvent.h"
 #include "webkit/default_plugin/plugin_impl.h"
 #include "webkit/glue/glue_util.h"
 #include "webkit/glue/webplugin.h"
 #include "webkit/glue/plugins/plugin_constants_win.h"
 #include "webkit/glue/plugins/plugin_instance.h"
 #include "webkit/glue/plugins/plugin_lib.h"
 #include "webkit/glue/plugins/plugin_list.h"
 #include "webkit/glue/plugins/plugin_stream_url.h"
 #include "webkit/glue/webkit_glue.h"
 
+using WebKit::WebKeyboardEvent;
+using WebKit::WebInputEvent;
+using WebKit::WebMouseEvent;
+
 namespace {
 
 const wchar_t kWebPluginDelegateProperty[] = L"WebPluginDelegateProperty";
 const wchar_t kPluginNameAtomProperty[] = L"PluginNameAtom";
 const wchar_t kDummyActivationWindowName[] = L"DummyWindowForActivation";
 const wchar_t kPluginOrigProc[] = L"OriginalPtr";
 const wchar_t kPluginFlashThrottle[] = L"FlashThrottle";
 
 // The fastest we are willing to process WM_USER+1 events for Flash.
 // Flash can easily exceed the limits of our CPU if we don't throttle it.
@@ skipping 217 matching lines @@
   if (!start_result)
     return false;
 
   windowless_ = instance_->windowless();
   if (!windowless_) {
     if (!WindowedCreatePlugin())
       return false;
   }
 
   plugin->SetWindow(windowed_handle_);
-#if defined(OS_WIN)
   if (windowless_) {
     // For windowless plugins we should set the containing window handle
     // as the instance window handle. This is what Safari does. Not having
     // a valid window handle causes subtle bugs with plugins which retreive
     // the window handle and validate the same. The window handle can be
     // retreived via NPN_GetValue of NPNVnetscapeWindow.
     instance_->set_window_handle(parent_);
+#if defined(OS_WIN)
     CreateDummyWindowForActivation();
     handle_event_pump_messages_event_ = CreateEvent(NULL, TRUE, FALSE, NULL);
     plugin->SetWindowlessPumpEvent(handle_event_pump_messages_event_);
+#endif
   }
-#endif
   plugin_url_ = url.spec();
 
   // The windowless version of the Silverlight plugin calls the
   // WindowFromPoint API and passes the result of that to the
   // TrackPopupMenu API call as the owner window. This causes the API
   // to fail as the API expects the window handle to live on the same
   // thread as the caller. It works in the other browsers as the plugin
   // lives on the browser thread. Our workaround is to intercept the
   // TrackPopupMenu API for Silverlight and replace the window handle
   // with the dummy activation window.
@@ skipping 706 matching lines @@
   DCHECK(instance()->windowless());
 
   NPEvent focus_event;
   focus_event.event = WM_SETFOCUS;
   focus_event.wParam = 0;
   focus_event.lParam = 0;
 
   instance()->NPP_HandleEvent(&focus_event);
 }
 
-bool WebPluginDelegateImpl::HandleEvent(NPEvent* event,
-                                        WebCursor* cursor) {
+static bool NPEventFromWebMouseEvent(const WebMouseEvent& event,
+                                     NPEvent *np_event) {
+  np_event->lParam = static_cast<uint32>(MAKELPARAM(event.windowX,
+                                                   event.windowY));
+  np_event->wParam = 0;
+
+  if (event.modifiers & WebInputEvent::ControlKey)
+    np_event->wParam |= MK_CONTROL;
+  if (event.modifiers & WebInputEvent::ShiftKey)
+    np_event->wParam |= MK_SHIFT;
+  if (event.modifiers & WebInputEvent::LeftButtonDown)
+    np_event->wParam |= MK_LBUTTON;
+  if (event.modifiers & WebInputEvent::MiddleButtonDown)
+    np_event->wParam |= MK_MBUTTON;
+  if (event.modifiers & WebInputEvent::RightButtonDown)
+    np_event->wParam |= MK_RBUTTON;
+
+  switch (event.type) {
+    case WebInputEvent::MouseMove:
+    case WebInputEvent::MouseLeave:
+    case WebInputEvent::MouseEnter:
+      np_event->event = WM_MOUSEMOVE;
+      return true;
+    case WebInputEvent::MouseDown:
+      switch (event.button) {
+        case WebMouseEvent::ButtonLeft:
+          np_event->event = WM_LBUTTONDOWN;
+          break;
+        case WebMouseEvent::ButtonMiddle:
+          np_event->event = WM_MBUTTONDOWN;
+          break;
+        case WebMouseEvent::ButtonRight:
+          np_event->event = WM_RBUTTONDOWN;
+          break;
+      }
+      return true;
+    case WebInputEvent::MouseUp:
+      switch (event.button) {
+        case WebMouseEvent::ButtonLeft:
+          np_event->event = WM_LBUTTONUP;
+          break;
+        case WebMouseEvent::ButtonMiddle:
+          np_event->event = WM_MBUTTONUP;
+          break;
+        case WebMouseEvent::ButtonRight:
+          np_event->event = WM_RBUTTONUP;
+          break;
+      }
+      return true;
+    default:
+      NOTREACHED();
+      return false;
+  }
+}
+
+static bool NPEventFromWebKeyboardEvent(const WebKeyboardEvent& event,
+                                        NPEvent *np_event) {
+  np_event->wParam = event.windowsKeyCode;
+
+  switch (event.type) {
+    case WebInputEvent::KeyDown:
+      np_event->event = WM_KEYDOWN;
+      np_event->lParam = 0;
+      return true;
+    case WebInputEvent::KeyUp:
+      np_event->event = WM_KEYUP;
+      np_event->lParam = 0x8000;
+      return true;
+    default:
+      NOTREACHED();
+      return false;
+  }
+}
+
+static bool NPEventFromWebInputEvent(const WebInputEvent& event,
+                                     NPEvent* np_event) {
+  switch (event.type) {
+    case WebInputEvent::MouseMove:
+    case WebInputEvent::MouseLeave:
+    case WebInputEvent::MouseEnter:
+    case WebInputEvent::MouseDown:
+    case WebInputEvent::MouseUp:
+      if (event.size < sizeof(WebMouseEvent)) {
+        NOTREACHED();
+        return false;
+      }
+      return NPEventFromWebMouseEvent(
+          *static_cast<const WebMouseEvent*>(&event), np_event);
+    case WebInputEvent::KeyDown:
+    case WebInputEvent::KeyUp:
+      if (event.size < sizeof(WebKeyboardEvent)) {
+        NOTREACHED();
+        return false;
+      }
+      return NPEventFromWebKeyboardEvent(
+          *static_cast<const WebKeyboardEvent*>(&event), np_event);
+    default:
+      return false;
+  }
+}
+
+bool WebPluginDelegateImpl::HandleInputEvent(const WebInputEvent& event,
+                                             WebCursor* cursor) {
   DCHECK(windowless_) << "events should only be received in windowless mode";
   DCHECK(cursor != NULL);
 
+  NPEvent np_event;
+  if (!NPEventFromWebInputEvent(event, &np_event)) {
+    return false;
+  }
+
   // To ensure that the plugin receives keyboard events we set focus to the
   // dummy window.
   // TODO(iyengar) We need a framework in the renderer to identify which
   // windowless plugin is under the mouse and to handle this. This would
   // also require some changes in RenderWidgetHost to detect this in the
   // WM_MOUSEACTIVATE handler and inform the renderer accordingly.
   HWND prev_focus_window = NULL;
-  if (event->event == WM_RBUTTONDOWN) {
+  if (np_event.event == WM_RBUTTONDOWN) {
     prev_focus_window = ::SetFocus(dummy_window_for_activation_);
   }
 
-  if (ShouldTrackEventForModalLoops(event)) {
+  if (ShouldTrackEventForModalLoops(&np_event)) {
     // A windowless plugin can enter a modal loop in a NPP_HandleEvent call.
     // For e.g. Flash puts up a context menu when we right click on the
     // windowless plugin area. We detect this by setting up a message filter
     // hook pror to calling NPP_HandleEvent on the plugin and unhook on
     // return from NPP_HandleEvent. If the plugin does enter a modal loop
     // in that context we unhook on receiving the first notification in
     // the message filter hook.
     handle_event_message_filter_hook_ =
         SetWindowsHookEx(WH_MSGFILTER, HandleEventMessageFilterHook, NULL,
                          GetCurrentThreadId());
   }
 
   bool old_task_reentrancy_state =
       MessageLoop::current()->NestableTasksAllowed();
 
 
   // Maintain a local/global stack for the g_current_plugin_instance variable
   // as this may be a nested invocation.
   WebPluginDelegateImpl* last_plugin_instance = g_current_plugin_instance;
 
   g_current_plugin_instance = this;
 
   handle_event_depth_++;
 
   bool pop_user_gesture = false;
 
-  if (IsUserGestureMessage(event->event)) {
+  if (IsUserGestureMessage(np_event.event)) {
     pop_user_gesture = true;
     instance()->PushPopupsEnabledState(true);
   }
 
-  bool ret = instance()->NPP_HandleEvent(event) != 0;
+  bool ret = instance()->NPP_HandleEvent(&np_event) != 0;
 
-  if (event->event == WM_MOUSEMOVE) {
+  if (np_event.event == WM_MOUSEMOVE) {
     // Snag a reference to the current cursor ASAP in case the plugin modified
     // it. There is a nasty race condition here with the multiprocess browser
     // as someone might be setting the cursor in the main process as well.
     *cursor = current_windowless_cursor_;
   }
 
   if (pop_user_gesture) {
     instance()->PopPopupsEnabledState();
   }
 
   handle_event_depth_--;
 
   g_current_plugin_instance = last_plugin_instance;
 
   MessageLoop::current()->SetNestableTasksAllowed(old_task_reentrancy_state);
 
   if (handle_event_message_filter_hook_) {
     UnhookWindowsHookEx(handle_event_message_filter_hook_);
     handle_event_message_filter_hook_ = NULL;
   }
 
   // We could have multiple NPP_HandleEvent calls nested together in case
   // the plugin enters a modal loop. Reset the pump messages event when
   // the outermost NPP_HandleEvent call unwinds.
   if (handle_event_depth_ == 0) {
     ResetEvent(handle_event_pump_messages_event_);
   }
 
-  if (event->event == WM_RBUTTONUP && ::IsWindow(prev_focus_window)) {
+  if (np_event.event == WM_RBUTTONUP && ::IsWindow(prev_focus_window)) {
     ::SetFocus(prev_focus_window);
   }
 
   return ret;
 }
 
 WebPluginResourceClient* WebPluginDelegateImpl::CreateResourceClient(
     int resource_id, const std::string &url, bool notify_needed,
     intptr_t notify_data, intptr_t existing_stream) {
   // Stream already exists. This typically happens for range requests
@@ skipping 91 matching lines @@
 
   // It is ok to pass NULL here to GetCursor as we are not looking for cursor
   // types defined by Webkit.
   HCURSOR previous_cursor =
       g_current_plugin_instance->current_windowless_cursor_.GetCursor(NULL);
 
   g_current_plugin_instance->current_windowless_cursor_.InitFromExternalCursor(
       cursor);
   return previous_cursor;
 }