Add support for custom cursors set by windowless plugins. Windowless plugins...

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_;
+iat_patch::IATPatchFunction WebPluginDelegateImpl::iat_patch_track_popup_menu_;
+iat_patch::IATPatchFunction WebPluginDelegateImpl::iat_patch_set_cursor_;
 
 WebPluginDelegateImpl* WebPluginDelegateImpl::Create(
     const FilePath& filename,
     const std::string& mime_type,
     gfx::NativeView containing_view) {
   scoped_refptr<NPAPI::PluginLib> plugin =
       NPAPI::PluginLib::CreatePluginLib(filename);
   if (plugin.get() == NULL)
     return NULL;
 
@@ skipping 84 matching lines @@
 
   const WebPluginInfo& plugin_info = instance_->plugin_lib()->plugin_info();
   std::wstring filename = plugin_info.file.BaseName().value();
 
   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();
     quirks_ |= PLUGIN_QUIRK_THROTTLE_WM_USER_PLUS_ONE;
+    quirks_ |= PLUGIN_QUIRK_PATCH_SETCURSOR;
   } else if (filename == L"nppdf32.dll") {
     // Check for the version number above or equal 9.
     std::vector<std::wstring> version;
     SplitString(plugin_info.version, L'.', &version);
     if (version.size() > 0) {
       int major = static_cast<int>(StringToInt64(version[0]));
       if (major >= 9) {
         quirks_ |= PLUGIN_QUIRK_DIE_AFTER_UNLOAD;
       }
     }
   } else if (plugin_info.name.find(L"Windows Media Player") !=
              std::wstring::npos) {
     // Windows Media Player needs two NPP_SetWindow calls.
     quirks_ |= PLUGIN_QUIRK_SETWINDOW_TWICE;
   } 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;
+    quirks_ |= PLUGIN_QUIRK_PATCH_SETCURSOR;
   }
 
   plugin_module_handle_ = ::GetModuleHandle(filename.c_str());
 }
 
 WebPluginDelegateImpl::~WebPluginDelegateImpl() {
   if (::IsWindow(dummy_window_for_activation_)) {
     ::DestroyWindow(dummy_window_for_activation_);
   }
 
@@ skipping 59 matching lines @@
   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_ &&
+  if (windowless_ && !iat_patch_track_popup_menu_.is_patched() &&
       (quirks_ & PLUGIN_QUIRK_PATCH_TRACKPOPUP_MENU)) {
-    iat_patch_helper_.Patch(plugin_module_handle_, "user32.dll",
-                            "TrackPopupMenu",
-                            WebPluginDelegateImpl::TrackPopupMenuPatch);
-    track_popup_menu_patched_ = true;
+    iat_patch_track_popup_menu_.Patch(
+        plugin_module_handle_, "user32.dll", "TrackPopupMenu",
+        WebPluginDelegateImpl::TrackPopupMenuPatch);
+  }
+
+  // Windowless plugins can set cursors by calling the SetCursor API. This
+  // works because the thread inputs of the browser UI thread and the plugin
+  // thread are attached. We intercept the SetCursor API for windowless plugins
+  // and remember the cursor being set. This is shipped over to the browser
+  // in the HandleEvent call, which ensures that the cursor does not change
+  // when a windowless plugin instance changes the cursor in a background tab.
+  if (windowless_ && !iat_patch_set_cursor_.is_patched() && 
+      (quirks_ & PLUGIN_QUIRK_PATCH_SETCURSOR)) {
+    iat_patch_set_cursor_.Patch(plugin_module_handle_, "user32.dll",
+                                "SetCursor",
+                                WebPluginDelegateImpl::SetCursorPatch);
   }
   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();
 
     window_.window = NULL;
     if (!(quirks_ & PLUGIN_QUIRK_DONT_SET_NULL_WINDOW_HANDLE_ON_DESTROY)) {
       instance_->NPP_SetWindow(&window_);
     }
 
     instance_->NPP_Destroy();
 
     instance_->set_web_plugin(NULL);
 
+    if (instance_->plugin_lib()) {
+      // Unpatch if this is the last plugin instance.
+      if (instance_->plugin_lib()->instance_count() == 1) {
+        if (iat_patch_set_cursor_.is_patched()) {
+          iat_patch_set_cursor_.Unpatch();
+        }
+
+        if (iat_patch_track_popup_menu_.is_patched()) {
+          iat_patch_track_popup_menu_.Unpatch();
+        }
+      }
+    }
+
     instance_ = 0;
   }
 }
 
 void WebPluginDelegateImpl::UpdateGeometry(
     const gfx::Rect& window_rect,
     const gfx::Rect& clip_rect,
     const std::vector<gfx::Rect>& cutout_rects,
     bool visible) {
   if (windowless_) {
@@ skipping 494 matching lines @@
       delegate->quirks() & PLUGIN_QUIRK_DONT_CALL_WND_PROC_RECURSIVELY &&
       delegate->is_calling_wndproc) {
     // Real may go into a state where it recursively dispatches the same event
     // when subclassed.  See https://bugzilla.mozilla.org/show_bug.cgi?id=192914
     // We only do the recursive check for Real because it's possible and valid
     // for a plugin to synchronously dispatch a message to itself such that it
     // looks like it's in recursion.
     return TRUE;
   }
 
+  current_plugin_instance_ = delegate;
+
   switch (message) {
     case WM_NCDESTROY: {
       RemoveProp(hwnd, kWebPluginDelegateProperty);
       ATOM plugin_name_atom = reinterpret_cast  <ATOM>(
           RemoveProp(hwnd, kPluginNameAtomProperty));
       if (plugin_name_atom != 0)
         GlobalDeleteAtom(plugin_name_atom);
       ClearThrottleQueueForWindow(hwnd);
       break;
     }
     // Flash may flood the message queue with WM_USER+1 message causing 100% CPU
     // usage.  See https://bugzilla.mozilla.org/show_bug.cgi?id=132759.  We
     // prevent this by throttling the messages.
     case WM_USER + 1: {
       if (delegate->quirks() & PLUGIN_QUIRK_THROTTLE_WM_USER_PLUS_ONE) {
         WebPluginDelegateImpl::ThrottleMessage(delegate->plugin_wnd_proc_, hwnd,
                                                message, wparam, lparam);
+        current_plugin_instance_ = NULL;
         return FALSE;
       }
       break;
     }
     default: {
       break;
     }
   }
 
   delegate->last_message_ = message;
   delegate->is_calling_wndproc = true;
 
   if (!delegate->user_gesture_message_posted_ && 
        IsUserGestureMessage(message)) {
     delegate->user_gesture_message_posted_ = true;
 
     delegate->instance()->PushPopupsEnabledState(true);
 
     MessageLoop::current()->PostTask(FROM_HERE,
         delegate->user_gesture_msg_factory_.NewRunnableMethod(
             &WebPluginDelegateImpl::OnUserGestureEnd));
   }
 
   LRESULT result = CallWindowProc(delegate->plugin_wnd_proc_, hwnd, message,
                                   wparam, lparam);
   delegate->is_calling_wndproc = false;
+  current_plugin_instance_ = NULL;
   return result;
 }
 
 void WebPluginDelegateImpl::WindowlessUpdateGeometry(
     const gfx::Rect& window_rect,
     const gfx::Rect& clip_rect) {
   // Only resend to the instance if the geometry has changed.
   if (window_rect == window_rect_ && clip_rect == clip_rect_)
     return;
 
@@ skipping 134 matching lines @@
 
   bool pop_user_gesture = false;
 
   if (IsUserGestureMessage(event->event)) {
     pop_user_gesture = true;
     instance()->PushPopupsEnabledState(true);
   }
 
   bool ret = instance()->NPP_HandleEvent(event) != 0;
 
-  // 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.
-  HCURSOR last_cursor;
-  if (WM_MOUSEMOVE == event->event) {
-    last_cursor = ::GetCursor();
+  if (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_--;
 
   current_plugin_instance_ = NULL;
 
   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)) {
     ::SetFocus(prev_focus_window);
   }
 
-  if (WM_MOUSEMOVE == event->event) {
-    cursor->InitFromCursor(last_cursor);
-  }
-
   return ret;
 }
 
 WebPluginResourceClient* WebPluginDelegateImpl::CreateResourceClient(
     int resource_id, const std::string &url, bool notify_needed,
     void *notify_data, void* existing_stream) {
   // Stream already exists. This typically happens for range requests
   // initiated via NPN_RequestRead.
   if (existing_stream) {
     NPAPI::PluginStream* plugin_stream =
@@ skipping 68 matching lines @@
     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);
 }
+
+HCURSOR WINAPI WebPluginDelegateImpl::SetCursorPatch(HCURSOR cursor) {
+  // The windowless flash plugin periodically calls SetCursor in a wndproc
+  // instantiated on the plugin thread. This causes annoying cursor flicker
+  // when the mouse is moved on a foreground tab, with a windowless plugin
+  // instance in a background tab. We just ignore the call here.
+  if (!current_plugin_instance_)
+    return GetCursor();
+
+  if (!current_plugin_instance_->windowless()) {
+    return SetCursor(cursor);
+  }
+
+  // It is ok to pass NULL here to GetCursor as we are not looking for cursor
+  // types defined by Webkit.
+  HCURSOR previous_cursor =
+      current_plugin_instance_->current_windowless_cursor_.GetCursor(NULL);
+
+  current_plugin_instance_->current_windowless_cursor_.InitFromExternalCursor(
+      cursor);
+  return previous_cursor;
+}