Ensure that the context menu shows up in a windowless Silverlight plugin...

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"
@@ skipping 29 matching lines @@
 // I'd like to make the throttle delay variable, based on the amount of
 // time currently required to paint Flash plugins.  There isn't a good
 // way to count the time spent in aggregate plugin painting, however, so
 // this seems to work well enough.
 static const int kFlashWMUSERMessageThrottleDelayMs = 5;
 
 std::list<MSG> WebPluginDelegateImpl::throttle_queue_;
 
 WebPluginDelegateImpl* WebPluginDelegateImpl::current_plugin_instance_ = NULL;
 
+bool WebPluginDelegateImpl::track_popup_menu_patched_ = false;
+iat_patch::IATPatchFunction WebPluginDelegateImpl::iat_patch_helper_;
+
 WebPluginDelegateImpl* WebPluginDelegateImpl::Create(
     const std::wstring& filename,
     const std::string& mime_type,
     HWND containing_window) {
   scoped_refptr<NPAPI::PluginLib> plugin =
       NPAPI::PluginLib::CreatePluginLib(filename);
   if (plugin.get() == NULL)
     return NULL;
 
   NPError err = plugin->NP_Initialize();
@@ skipping 70 matching lines @@
       plugin_wnd_proc_(NULL),
       last_message_(0),
       is_calling_wndproc(false),
       initial_plugin_resize_done_(false),
       dummy_window_for_activation_(NULL),
       handle_event_message_filter_hook_(NULL),
       handle_event_pump_messages_event_(NULL),
       handle_event_depth_(0),
       user_gesture_message_posted_(false),
 #pragma warning(suppress: 4355)  // can use this
-      user_gesture_msg_factory_(this) {
+      user_gesture_msg_factory_(this),
+      plugin_module_handle_(NULL) {
   memset(&window_, 0, sizeof(window_));
 
   const WebPluginInfo& plugin_info = instance_->plugin_lib()->plugin_info();
   std::wstring filename = file_util::GetFilenameFromPath(plugin_info.file);
 
   if (instance_->mime_type() == "application/x-shockwave-flash" ||
       filename == L"npswf32.dll") {
     // Flash only requests windowless plugins if we return a Mozilla user
     // agent.
     instance_->set_use_mozilla_user_agent();
@@ skipping 15 matching lines @@
   } else if (instance_->mime_type() == "audio/x-pn-realaudio-plugin" ||
              filename == L"nppl3260.dll") {
     quirks_ |= PLUGIN_QUIRK_DONT_CALL_WND_PROC_RECURSIVELY;
   } else if (plugin_info.name.find(L"VLC Multimedia Plugin") !=
              std::wstring::npos) {
     // VLC hangs on NPP_Destroy if we call NPP_SetWindow with a null window
     // handle
     quirks_ |= PLUGIN_QUIRK_DONT_SET_NULL_WINDOW_HANDLE_ON_DESTROY;
     // VLC 0.8.6d and 0.8.6e crash if multiple instances are created.
     quirks_ |= PLUGIN_QUIRK_DONT_ALLOW_MULTIPLE_INSTANCES;
+  } else if (filename == L"npctrl.dll") {
+    // Explanation for this quirk can be found in
+    // WebPluginDelegateImpl::Initialize.
+    quirks_ |= PLUGIN_QUIRK_PATCH_TRACKPOPUP_MENU;
   }
+
+  plugin_module_handle_ = ::GetModuleHandle(filename.c_str());
 }
 
 WebPluginDelegateImpl::~WebPluginDelegateImpl() {
   if (::IsWindow(dummy_window_for_activation_)) {
     ::DestroyWindow(dummy_window_for_activation_);
   }
 
   DestroyInstance();
 
   if (!windowless_)
@@ skipping 46 matching lines @@
     // retreived via NPN_GetValue of NPNVnetscapeWindow.
     instance_->set_window_handle(parent_);
     CreateDummyWindowForActivation();
     handle_event_pump_messages_event_ = CreateEvent(NULL, TRUE, FALSE, NULL);
   } else {
     if (!WindowedCreatePlugin())
       return false;
   }
 
   plugin->SetWindow(windowed_handle_, handle_event_pump_messages_event_);
+  plugin_url_ = url.spec();
 
-  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.
+  if (windowless_ && !track_popup_menu_patched_ &&
+      (quirks_ & PLUGIN_QUIRK_PATCH_TRACKPOPUP_MENU)) {
+    iat_patch_helper_.Patch(plugin_module_handle_, "user32.dll",
+                            "TrackPopupMenu",
+                            WebPluginDelegateImpl::TrackPopupMenuPatch);
+    track_popup_menu_patched_ = true;
+  }
   return true;
 }
 
 void WebPluginDelegateImpl::DestroyInstance() {
   if (instance_ && (instance_->npp()->ndata != NULL)) {
     // Shutdown all streams before destroying so that
     // no streams are left "in progress".  Need to do
     // this before calling set_web_plugin(NULL) because the
     // instance uses the helper to do the download.
     instance_->CloseStreams();
@@ skipping 741 matching lines @@
     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 (::IsWindow(prev_focus_window)) {
+  if (event->event == WM_RBUTTONUP && ::IsWindow(prev_focus_window)) {
     ::SetFocus(prev_focus_window);
   }
 
   if (WM_MOUSEMOVE == event->event) {
     cursor->InitFromCursor(last_cursor);
   }
 
   return ret;
 }
 
@@ skipping 59 matching lines @@
       break;
   }
 
   return false;
 }
 
 void WebPluginDelegateImpl::OnUserGestureEnd() {
   user_gesture_message_posted_ = false;
   instance()->PopPopupsEnabledState();
 }
+
+BOOL WINAPI WebPluginDelegateImpl::TrackPopupMenuPatch(
+    HMENU menu, unsigned int flags, int x, int y, int reserved,
+    HWND window, const RECT* rect) {
+  if (current_plugin_instance_) {
+    unsigned long window_process_id = 0;
+    unsigned long window_thread_id =
+        GetWindowThreadProcessId(window, &window_process_id);
+    // TrackPopupMenu fails if the window passed in belongs to a different
+    // thread.
+    if (::GetCurrentThreadId() != window_thread_id) {
+      window = current_plugin_instance_->dummy_window_for_activation_;
+    }
+  }
+  return TrackPopupMenu(menu, flags, x, y, reserved, window, rect);
+}