| Index: content/child/npapi/webplugin_delegate_impl_win.cc
|
| diff --git a/content/child/npapi/webplugin_delegate_impl_win.cc b/content/child/npapi/webplugin_delegate_impl_win.cc
|
| index f0213e372fe732025ddf6865d1a32f39c85cf209..70657052b54e87efceccbebca5a37be871eef25b 100644
|
| --- a/content/child/npapi/webplugin_delegate_impl_win.cc
|
| +++ b/content/child/npapi/webplugin_delegate_impl_win.cc
|
| @@ -22,13 +22,10 @@
|
| #include "base/strings/stringprintf.h"
|
| #include "base/synchronization/lock.h"
|
| #include "base/version.h"
|
| -#include "base/win/iat_patch_function.h"
|
| -#include "base/win/registry.h"
|
| #include "base/win/windows_version.h"
|
| #include "content/child/npapi/plugin_instance.h"
|
| #include "content/child/npapi/plugin_lib.h"
|
| #include "content/child/npapi/webplugin.h"
|
| -#include "content/child/npapi/webplugin_ime_win.h"
|
| #include "content/common/cursors/webcursor.h"
|
| #include "content/common/plugin_constants_win.h"
|
| #include "content/public/common/content_constants.h"
|
| @@ -45,47 +42,6 @@ namespace content {
|
|
|
| namespace {
|
|
|
| -const wchar_t kWebPluginDelegateProperty[] = L"WebPluginDelegateProperty";
|
| -
|
| -// 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.
|
| -// The throttle has been chosen by testing various delays and compromising
|
| -// on acceptable Flash performance and reasonable CPU consumption.
|
| -//
|
| -// 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.
|
| -const int kFlashWMUSERMessageThrottleDelayMs = 5;
|
| -
|
| -// The current instance of the plugin which entered the modal loop.
|
| -WebPluginDelegateImpl* g_current_plugin_instance = NULL;
|
| -
|
| -typedef std::deque<MSG> ThrottleQueue;
|
| -base::LazyInstance<ThrottleQueue> g_throttle_queue = LAZY_INSTANCE_INITIALIZER;
|
| -
|
| -base::LazyInstance<std::map<HWND, WNDPROC> > g_window_handle_proc_map =
|
| - LAZY_INSTANCE_INITIALIZER;
|
| -
|
| -// Helper object for patching the TrackPopupMenu API.
|
| -base::LazyInstance<base::win::IATPatchFunction> g_iat_patch_track_popup_menu =
|
| - LAZY_INSTANCE_INITIALIZER;
|
| -
|
| -// Helper object for patching the SetCursor API.
|
| -base::LazyInstance<base::win::IATPatchFunction> g_iat_patch_set_cursor =
|
| - LAZY_INSTANCE_INITIALIZER;
|
| -
|
| -// Helper object for patching the RegEnumKeyExW API.
|
| -base::LazyInstance<base::win::IATPatchFunction> g_iat_patch_reg_enum_key_ex_w =
|
| - LAZY_INSTANCE_INITIALIZER;
|
| -
|
| -// Helper object for patching the GetProcAddress API.
|
| -base::LazyInstance<base::win::IATPatchFunction> g_iat_patch_get_proc_address =
|
| - LAZY_INSTANCE_INITIALIZER;
|
| -
|
| -base::LazyInstance<base::win::IATPatchFunction> g_iat_patch_window_from_point =
|
| - LAZY_INSTANCE_INITIALIZER;
|
| -
|
| // http://crbug.com/16114
|
| // Enforces providing a valid device context in NPWindow, so that NPP_SetWindow
|
| // is never called with NPNWindoTypeDrawable and NPWindow set to NULL.
|
| @@ -118,104 +74,13 @@ class DrawableContextEnforcer {
|
| bool disposable_dc_;
|
| };
|
|
|
| -// These are from ntddk.h
|
| -typedef LONG NTSTATUS;
|
| -
|
| -#ifndef STATUS_SUCCESS
|
| -#define STATUS_SUCCESS ((NTSTATUS)0x00000000L)
|
| -#endif
|
| -
|
| -#ifndef STATUS_BUFFER_TOO_SMALL
|
| -#define STATUS_BUFFER_TOO_SMALL ((NTSTATUS)0xC0000023L)
|
| -#endif
|
| -
|
| -typedef enum _KEY_INFORMATION_CLASS {
|
| - KeyBasicInformation,
|
| - KeyNodeInformation,
|
| - KeyFullInformation,
|
| - KeyNameInformation,
|
| - KeyCachedInformation,
|
| - KeyVirtualizationInformation
|
| -} KEY_INFORMATION_CLASS;
|
| -
|
| -typedef struct _KEY_NAME_INFORMATION {
|
| - ULONG NameLength;
|
| - WCHAR Name[1];
|
| -} KEY_NAME_INFORMATION, *PKEY_NAME_INFORMATION;
|
| -
|
| -typedef DWORD (__stdcall *ZwQueryKeyType)(
|
| - HANDLE key_handle,
|
| - int key_information_class,
|
| - PVOID key_information,
|
| - ULONG length,
|
| - PULONG result_length);
|
| -
|
| -// Returns a key's full path.
|
| -std::wstring GetKeyPath(HKEY key) {
|
| - if (key == NULL)
|
| - return L"";
|
| -
|
| - HMODULE dll = GetModuleHandle(L"ntdll.dll");
|
| - if (dll == NULL)
|
| - return L"";
|
| -
|
| - ZwQueryKeyType func = reinterpret_cast<ZwQueryKeyType>(
|
| - ::GetProcAddress(dll, "ZwQueryKey"));
|
| - if (func == NULL)
|
| - return L"";
|
| -
|
| - DWORD size = 0;
|
| - DWORD result = 0;
|
| - result = func(key, KeyNameInformation, 0, 0, &size);
|
| - if (result != static_cast<DWORD>(STATUS_BUFFER_TOO_SMALL))
|
| - return L"";
|
| -
|
| - scoped_ptr<char[]> buffer(new char[size]);
|
| - if (buffer.get() == NULL)
|
| - return L"";
|
| -
|
| - result = func(key, KeyNameInformation, buffer.get(), size, &size);
|
| - if (result != static_cast<DWORD>(STATUS_SUCCESS))
|
| - return L"";
|
| -
|
| - KEY_NAME_INFORMATION* info =
|
| - reinterpret_cast<KEY_NAME_INFORMATION*>(buffer.get());
|
| - return std::wstring(info->Name, info->NameLength / sizeof(wchar_t));
|
| -}
|
| -
|
| -uint32_t GetPluginMajorVersion(const WebPluginInfo& plugin_info) {
|
| - Version plugin_version;
|
| - WebPluginInfo::CreateVersionFromString(plugin_info.version, &plugin_version);
|
| -
|
| - uint32_t major_version = 0;
|
| - if (plugin_version.IsValid())
|
| - major_version = plugin_version.components()[0];
|
| -
|
| - return major_version;
|
| -}
|
| -
|
| } // namespace
|
|
|
| -LRESULT CALLBACK WebPluginDelegateImpl::HandleEventMessageFilterHook(
|
| - int code, WPARAM wParam, LPARAM lParam) {
|
| - if (g_current_plugin_instance) {
|
| - g_current_plugin_instance->OnModalLoopEntered();
|
| - } else {
|
| - NOTREACHED();
|
| - }
|
| - return CallNextHookEx(NULL, code, wParam, lParam);
|
| -}
|
| -
|
| WebPluginDelegateImpl::WebPluginDelegateImpl(WebPlugin* plugin,
|
| PluginInstance* instance)
|
| : plugin_(plugin),
|
| instance_(instance),
|
| quirks_(0),
|
| - dummy_window_for_activation_(NULL),
|
| - dummy_window_parent_(NULL),
|
| - old_dummy_window_proc_(NULL),
|
| - handle_event_message_filter_hook_(NULL),
|
| - handle_event_pump_messages_event_(NULL),
|
| handle_event_depth_(0),
|
| first_set_window_call_(true),
|
| plugin_has_focus_(false),
|
| @@ -224,182 +89,17 @@ WebPluginDelegateImpl::WebPluginDelegateImpl(WebPlugin* plugin,
|
| creation_succeeded_(false),
|
| user_gesture_msg_factory_(this) {
|
| memset(&window_, 0, sizeof(window_));
|
| -
|
| - const WebPluginInfo& plugin_info = instance_->plugin_lib()->plugin_info();
|
| - base::string16 filename =
|
| - base::ToLowerASCII(plugin_info.path.BaseName().value());
|
| -
|
| - if (instance_->mime_type() == kFlashPluginSwfMimeType ||
|
| - filename == kFlashPlugin) {
|
| - // 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;
|
| - quirks_ |= PLUGIN_QUIRK_ALWAYS_NOTIFY_SUCCESS;
|
| - quirks_ |= PLUGIN_QUIRK_HANDLE_MOUSE_CAPTURE;
|
| - quirks_ |= PLUGIN_QUIRK_EMULATE_IME;
|
| - quirks_ |= PLUGIN_QUIRK_FAKE_WINDOW_FROM_POINT;
|
| - } else if (filename == kAcrobatReaderPlugin) {
|
| - // Check for the version number above or equal 9.
|
| - uint32_t major_version = GetPluginMajorVersion(plugin_info);
|
| - if (major_version >= 9) {
|
| - quirks_ |= PLUGIN_QUIRK_DIE_AFTER_UNLOAD;
|
| - // 9.2 needs this.
|
| - quirks_ |= PLUGIN_QUIRK_SETWINDOW_TWICE;
|
| - }
|
| - quirks_ |= PLUGIN_QUIRK_BLOCK_NONSTANDARD_GETURL_REQUESTS;
|
| - } 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;
|
| -
|
| - // Windowless mode doesn't work in the WMP NPAPI plugin.
|
| - quirks_ |= PLUGIN_QUIRK_NO_WINDOWLESS;
|
| -
|
| - // The media player plugin sets its size on the first NPP_SetWindow call
|
| - // and never updates its size. We should call the underlying NPP_SetWindow
|
| - // only when we have the correct size.
|
| - quirks_ |= PLUGIN_QUIRK_IGNORE_FIRST_SETWINDOW_CALL;
|
| -
|
| - if (filename == kOldWMPPlugin) {
|
| - // Non-admin users on XP couldn't modify the key to force the new UI.
|
| - quirks_ |= PLUGIN_QUIRK_PATCH_REGENUMKEYEXW;
|
| - }
|
| - } else if (instance_->mime_type() == "audio/x-pn-realaudio-plugin" ||
|
| - filename == kRealPlayerPlugin) {
|
| - quirks_ |= PLUGIN_QUIRK_DONT_CALL_WND_PROC_RECURSIVELY;
|
| - } else if (plugin_info.name.find(L"VLC Multimedia Plugin") !=
|
| - std::wstring::npos ||
|
| - plugin_info.name.find(L"VLC Multimedia Plug-in") !=
|
| - 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;
|
| - uint32_t major_version = GetPluginMajorVersion(plugin_info);
|
| - if (major_version == 0) {
|
| - // VLC 0.8.6d and 0.8.6e crash if multiple instances are created.
|
| - quirks_ |= PLUGIN_QUIRK_DONT_ALLOW_MULTIPLE_INSTANCES;
|
| - }
|
| - } else if (filename == kSilverlightPlugin) {
|
| - // Explanation for this quirk can be found in
|
| - // WebPluginDelegateImpl::Initialize.
|
| - quirks_ |= PLUGIN_QUIRK_PATCH_SETCURSOR;
|
| - } else if (plugin_info.name.find(L"DivX Web Player") !=
|
| - std::wstring::npos) {
|
| - // The divx plugin sets its size on the first NPP_SetWindow call and never
|
| - // updates its size. We should call the underlying NPP_SetWindow only when
|
| - // we have the correct size.
|
| - quirks_ |= PLUGIN_QUIRK_IGNORE_FIRST_SETWINDOW_CALL;
|
| - }
|
| }
|
|
|
| WebPluginDelegateImpl::~WebPluginDelegateImpl() {
|
| - if (::IsWindow(dummy_window_for_activation_)) {
|
| - WNDPROC current_wnd_proc = reinterpret_cast<WNDPROC>(
|
| - GetWindowLongPtr(dummy_window_for_activation_, GWLP_WNDPROC));
|
| - if (current_wnd_proc == DummyWindowProc) {
|
| - SetWindowLongPtr(dummy_window_for_activation_,
|
| - GWLP_WNDPROC,
|
| - reinterpret_cast<LONG_PTR>(old_dummy_window_proc_));
|
| - }
|
| - ::DestroyWindow(dummy_window_for_activation_);
|
| - }
|
| -
|
| DestroyInstance();
|
| -
|
| - if (handle_event_pump_messages_event_) {
|
| - CloseHandle(handle_event_pump_messages_event_);
|
| - }
|
| }
|
|
|
| bool WebPluginDelegateImpl::PlatformInitialize() {
|
| - CreateDummyWindowForActivation();
|
| - handle_event_pump_messages_event_ = CreateEvent(NULL, TRUE, FALSE, NULL);
|
| - plugin_->SetWindowlessData(
|
| - handle_event_pump_messages_event_,
|
| - reinterpret_cast<gfx::NativeViewId>(dummy_window_for_activation_));
|
| -
|
| - // Windowless plugins call 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 and replace the window handle with the dummy activation window.
|
| - if (!g_iat_patch_track_popup_menu.Pointer()->is_patched()) {
|
| - g_iat_patch_track_popup_menu.Pointer()->Patch(
|
| - GetPluginPath().value().c_str(), "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 (!g_iat_patch_set_cursor.Pointer()->is_patched() &&
|
| - (quirks_ & PLUGIN_QUIRK_PATCH_SETCURSOR)) {
|
| - g_iat_patch_set_cursor.Pointer()->Patch(
|
| - GetPluginPath().value().c_str(), "user32.dll", "SetCursor",
|
| - WebPluginDelegateImpl::SetCursorPatch);
|
| - }
|
| -
|
| - // On XP, WMP will use its old UI unless a registry key under HKLM has the
|
| - // name of the current process. We do it in the installer for admin users,
|
| - // for the rest patch this function.
|
| - if ((quirks_ & PLUGIN_QUIRK_PATCH_REGENUMKEYEXW) &&
|
| - base::win::GetVersion() == base::win::VERSION_XP &&
|
| - (base::win::RegKey().Open(HKEY_LOCAL_MACHINE,
|
| - L"SOFTWARE\\Microsoft\\MediaPlayer\\ShimInclusionList\\chrome.exe",
|
| - KEY_READ) != ERROR_SUCCESS) &&
|
| - !g_iat_patch_reg_enum_key_ex_w.Pointer()->is_patched()) {
|
| - g_iat_patch_reg_enum_key_ex_w.Pointer()->Patch(
|
| - L"wmpdxm.dll", "advapi32.dll", "RegEnumKeyExW",
|
| - WebPluginDelegateImpl::RegEnumKeyExWPatch);
|
| - }
|
| -
|
| - // Flash retrieves the pointers to IMM32 functions with GetProcAddress() calls
|
| - // and use them to retrieve IME data. We add a patch to this function so we
|
| - // can dispatch these IMM32 calls to the WebPluginIMEWin class, which emulates
|
| - // IMM32 functions for Flash.
|
| - if (!g_iat_patch_get_proc_address.Pointer()->is_patched() &&
|
| - (quirks_ & PLUGIN_QUIRK_EMULATE_IME)) {
|
| - g_iat_patch_get_proc_address.Pointer()->Patch(
|
| - GetPluginPath().value().c_str(), "kernel32.dll", "GetProcAddress",
|
| - GetProcAddressPatch);
|
| - }
|
| -
|
| - if (!g_iat_patch_window_from_point.Pointer()->is_patched() &&
|
| - (quirks_ & PLUGIN_QUIRK_FAKE_WINDOW_FROM_POINT)) {
|
| - g_iat_patch_window_from_point.Pointer()->Patch(
|
| - GetPluginPath().value().c_str(), "user32.dll", "WindowFromPoint",
|
| - WebPluginDelegateImpl::WindowFromPointPatch);
|
| - }
|
| -
|
| return true;
|
| }
|
|
|
| void WebPluginDelegateImpl::PlatformDestroyInstance() {
|
| - if (!instance_->plugin_lib())
|
| - return;
|
| -
|
| - // Unpatch if this is the last plugin instance.
|
| - if (instance_->plugin_lib()->instance_count() != 1)
|
| - return;
|
| -
|
| - if (g_iat_patch_set_cursor.Pointer()->is_patched())
|
| - g_iat_patch_set_cursor.Pointer()->Unpatch();
|
| -
|
| - if (g_iat_patch_track_popup_menu.Pointer()->is_patched())
|
| - g_iat_patch_track_popup_menu.Pointer()->Unpatch();
|
| -
|
| - if (g_iat_patch_reg_enum_key_ex_w.Pointer()->is_patched())
|
| - g_iat_patch_reg_enum_key_ex_w.Pointer()->Unpatch();
|
| -
|
| - if (g_iat_patch_window_from_point.Pointer()->is_patched())
|
| - g_iat_patch_window_from_point.Pointer()->Unpatch();
|
| }
|
|
|
| void WebPluginDelegateImpl::Paint(SkCanvas* canvas, const gfx::Rect& rect) {
|
| @@ -410,234 +110,6 @@ void WebPluginDelegateImpl::Paint(SkCanvas* canvas, const gfx::Rect& rect) {
|
| }
|
| }
|
|
|
| -// Erase all messages in the queue destined for a particular window.
|
| -// When windows are closing, callers should use this function to clear
|
| -// the queue.
|
| -// static
|
| -void WebPluginDelegateImpl::ClearThrottleQueueForWindow(HWND window) {
|
| - ThrottleQueue* throttle_queue = g_throttle_queue.Pointer();
|
| -
|
| - ThrottleQueue::iterator it;
|
| - for (it = throttle_queue->begin(); it != throttle_queue->end(); ) {
|
| - if (it->hwnd == window) {
|
| - it = throttle_queue->erase(it);
|
| - } else {
|
| - it++;
|
| - }
|
| - }
|
| -}
|
| -
|
| -// Delayed callback for processing throttled messages.
|
| -// Throttled messages are aggregated globally across all plugins.
|
| -// static
|
| -void WebPluginDelegateImpl::OnThrottleMessage() {
|
| - // The current algorithm walks the list and processes the first
|
| - // message it finds for each plugin. It is important to service
|
| - // all active plugins with each pass through the throttle, otherwise
|
| - // we see video jankiness. Copy the set to notify before notifying
|
| - // since we may re-enter OnThrottleMessage from CallWindowProc!
|
| - ThrottleQueue* throttle_queue = g_throttle_queue.Pointer();
|
| - ThrottleQueue notify_queue;
|
| - std::set<HWND> processed;
|
| -
|
| - ThrottleQueue::iterator it = throttle_queue->begin();
|
| - while (it != throttle_queue->end()) {
|
| - const MSG& msg = *it;
|
| - if (processed.find(msg.hwnd) == processed.end()) {
|
| - processed.insert(msg.hwnd);
|
| - notify_queue.push_back(msg);
|
| - it = throttle_queue->erase(it);
|
| - } else {
|
| - it++;
|
| - }
|
| - }
|
| -
|
| - // Due to re-entrancy, we must save our queue state now. Otherwise, we may
|
| - // self-post below, and *also* start up another delayed task when the first
|
| - // entry is pushed onto the queue in ThrottleMessage().
|
| - bool throttle_queue_was_empty = throttle_queue->empty();
|
| -
|
| - for (it = notify_queue.begin(); it != notify_queue.end(); ++it) {
|
| - const MSG& msg = *it;
|
| - WNDPROC proc = reinterpret_cast<WNDPROC>(msg.time);
|
| - // It is possible that the window was closed after we queued
|
| - // this message. This is a rare event; just verify the window
|
| - // is alive. (see also bug 1259488)
|
| - if (IsWindow(msg.hwnd))
|
| - CallWindowProc(proc, msg.hwnd, msg.message, msg.wParam, msg.lParam);
|
| - }
|
| -
|
| - if (!throttle_queue_was_empty) {
|
| - base::MessageLoop::current()->PostDelayedTask(
|
| - FROM_HERE,
|
| - base::Bind(&WebPluginDelegateImpl::OnThrottleMessage),
|
| - base::TimeDelta::FromMilliseconds(kFlashWMUSERMessageThrottleDelayMs));
|
| - }
|
| -}
|
| -
|
| -// Schedule a windows message for delivery later.
|
| -// static
|
| -void WebPluginDelegateImpl::ThrottleMessage(WNDPROC proc, HWND hwnd,
|
| - UINT message, WPARAM wParam,
|
| - LPARAM lParam) {
|
| - MSG msg;
|
| - // Cast through uintptr_t and then DWORD to make the truncation explicit.
|
| - msg.time = static_cast<DWORD>(reinterpret_cast<uintptr_t>(proc));
|
| - msg.hwnd = hwnd;
|
| - msg.message = message;
|
| - msg.wParam = wParam;
|
| - msg.lParam = lParam;
|
| -
|
| - ThrottleQueue* throttle_queue = g_throttle_queue.Pointer();
|
| -
|
| - throttle_queue->push_back(msg);
|
| -
|
| - if (throttle_queue->size() == 1) {
|
| - base::MessageLoop::current()->PostDelayedTask(
|
| - FROM_HERE,
|
| - base::Bind(&WebPluginDelegateImpl::OnThrottleMessage),
|
| - base::TimeDelta::FromMilliseconds(kFlashWMUSERMessageThrottleDelayMs));
|
| - }
|
| -}
|
| -
|
| -// We go out of our way to find the hidden windows created by Flash for
|
| -// windowless plugins. We throttle the rate at which they deliver messages
|
| -// so that they will not consume outrageous amounts of CPU.
|
| -// static
|
| -LRESULT CALLBACK WebPluginDelegateImpl::FlashWindowlessWndProc(
|
| - HWND hwnd, UINT message, WPARAM wparam, LPARAM lparam) {
|
| - std::map<HWND, WNDPROC>::iterator index =
|
| - g_window_handle_proc_map.Get().find(hwnd);
|
| -
|
| - WNDPROC old_proc = (*index).second;
|
| - DCHECK(old_proc);
|
| -
|
| - switch (message) {
|
| - case WM_NCDESTROY: {
|
| - WebPluginDelegateImpl::ClearThrottleQueueForWindow(hwnd);
|
| - g_window_handle_proc_map.Get().erase(index);
|
| - 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: {
|
| - WebPluginDelegateImpl::ThrottleMessage(old_proc, hwnd, message, wparam,
|
| - lparam);
|
| - return TRUE;
|
| - }
|
| -
|
| - default: {
|
| - break;
|
| - }
|
| - }
|
| - return CallWindowProc(old_proc, hwnd, message, wparam, lparam);
|
| -}
|
| -
|
| -LRESULT CALLBACK WebPluginDelegateImpl::DummyWindowProc(
|
| - HWND hwnd, UINT message, WPARAM w_param, LPARAM l_param) {
|
| - WebPluginDelegateImpl* delegate = reinterpret_cast<WebPluginDelegateImpl*>(
|
| - GetProp(hwnd, kWebPluginDelegateProperty));
|
| - CHECK(delegate);
|
| - if (message == WM_WINDOWPOSCHANGING) {
|
| - // We need to know when the dummy window is parented because windowless
|
| - // plugins need the parent window for things like menus. There's no message
|
| - // for a parent being changed, but a WM_WINDOWPOSCHANGING is sent so we
|
| - // check every time we get it.
|
| - // For non-aura builds, this never changes since RenderWidgetHostViewWin's
|
| - // window is constant. For aura builds, this changes every time the tab gets
|
| - // dragged to a new window.
|
| - HWND parent = GetParent(hwnd);
|
| - if (parent != delegate->dummy_window_parent_) {
|
| - delegate->dummy_window_parent_ = parent;
|
| -
|
| - // 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 retrieve the window handle and use it for things
|
| - // like context menus. The window handle can be retrieved via
|
| - // NPN_GetValue of NPNVnetscapeWindow.
|
| - delegate->instance_->set_window_handle(parent);
|
| -
|
| - // The plugin caches the result of NPNVnetscapeWindow when we originally
|
| - // called NPP_SetWindow, so force it to get the new value.
|
| - delegate->WindowlessSetWindow();
|
| - }
|
| - } else if (message == WM_NCDESTROY) {
|
| - RemoveProp(hwnd, kWebPluginDelegateProperty);
|
| - }
|
| - return CallWindowProc(
|
| - delegate->old_dummy_window_proc_, hwnd, message, w_param, l_param);
|
| -}
|
| -
|
| -// Callback for enumerating the Flash windows.
|
| -BOOL CALLBACK EnumFlashWindows(HWND window, LPARAM arg) {
|
| - WNDPROC wnd_proc = reinterpret_cast<WNDPROC>(arg);
|
| - TCHAR class_name[1024];
|
| - if (!RealGetWindowClass(window, class_name,
|
| - sizeof(class_name)/sizeof(TCHAR))) {
|
| - LOG(ERROR) << "RealGetWindowClass failure: " << GetLastError();
|
| - return FALSE;
|
| - }
|
| -
|
| - if (wcscmp(class_name, L"SWFlash_PlaceholderX"))
|
| - return TRUE;
|
| -
|
| - WNDPROC current_wnd_proc = reinterpret_cast<WNDPROC>(
|
| - GetWindowLongPtr(window, GWLP_WNDPROC));
|
| - if (current_wnd_proc != wnd_proc) {
|
| - WNDPROC old_flash_proc = reinterpret_cast<WNDPROC>(SetWindowLongPtr(
|
| - window, GWLP_WNDPROC,
|
| - reinterpret_cast<LONG_PTR>(wnd_proc)));
|
| - DCHECK(old_flash_proc);
|
| - g_window_handle_proc_map.Get()[window] = old_flash_proc;
|
| - }
|
| -
|
| - return TRUE;
|
| -}
|
| -
|
| -bool WebPluginDelegateImpl::CreateDummyWindowForActivation() {
|
| - DCHECK(!dummy_window_for_activation_);
|
| -
|
| - dummy_window_for_activation_ = CreateWindowEx(
|
| - 0,
|
| - L"Static",
|
| - kDummyActivationWindowName,
|
| - WS_CHILD,
|
| - 0,
|
| - 0,
|
| - 0,
|
| - 0,
|
| - // We don't know the parent of the dummy window yet, so just set it to the
|
| - // desktop and it'll get parented by the browser.
|
| - GetDesktopWindow(),
|
| - 0,
|
| - GetModuleHandle(NULL),
|
| - 0);
|
| -
|
| - if (dummy_window_for_activation_ == 0)
|
| - return false;
|
| -
|
| - BOOL result = SetProp(dummy_window_for_activation_,
|
| - kWebPluginDelegateProperty, this);
|
| - DCHECK(result == TRUE) << "SetProp failed, last error = " << GetLastError();
|
| - old_dummy_window_proc_ = reinterpret_cast<WNDPROC>(SetWindowLongPtr(
|
| - dummy_window_for_activation_, GWLP_WNDPROC,
|
| - reinterpret_cast<LONG_PTR>(DummyWindowProc)));
|
| -
|
| - // Flash creates background windows which use excessive CPU in our
|
| - // environment; we wrap these windows and throttle them so that they don't
|
| - // get out of hand.
|
| - if (!EnumThreadWindows(::GetCurrentThreadId(), EnumFlashWindows,
|
| - reinterpret_cast<LPARAM>(
|
| - &WebPluginDelegateImpl::FlashWindowlessWndProc))) {
|
| - // Log that this happened. Flash will still work; it just means the
|
| - // throttle isn't installed (and Flash will use more CPU).
|
| - NOTREACHED();
|
| - LOG(ERROR) << "Failed to wrap all windowless Flash windows";
|
| - }
|
| - return true;
|
| -}
|
| -
|
| // Returns true if the message passed in corresponds to a user gesture.
|
| static bool IsUserGestureMessage(unsigned int message) {
|
| switch (message) {
|
| @@ -860,51 +332,6 @@ bool WebPluginDelegateImpl::PlatformHandleInputEvent(
|
| return false;
|
| }
|
|
|
| - // Allow this plugin to access this IME emulator through IMM32 API while the
|
| - // plugin is processing this event.
|
| - if (GetQuirks() & PLUGIN_QUIRK_EMULATE_IME) {
|
| - if (!plugin_ime_)
|
| - plugin_ime_.reset(new WebPluginIMEWin);
|
| - }
|
| - WebPluginIMEWin::ScopedLock lock(
|
| - event.isKeyboardEventType(event.type) ? plugin_ime_.get() : NULL);
|
| -
|
| - HWND last_focus_window = NULL;
|
| -
|
| - 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());
|
| - // 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.
|
| - bool valid = GetParent(dummy_window_for_activation_) != GetDesktopWindow();
|
| - if (valid) {
|
| - last_focus_window = ::SetFocus(dummy_window_for_activation_);
|
| - } else {
|
| - NOTREACHED() << "Dummy window not parented";
|
| - }
|
| - }
|
| -
|
| - bool old_task_reentrancy_state =
|
| - base::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 popups_enabled = false;
|
| @@ -936,174 +363,7 @@ bool WebPluginDelegateImpl::PlatformHandleInputEvent(
|
|
|
| handle_event_depth_--;
|
|
|
| - g_current_plugin_instance = last_plugin_instance;
|
| -
|
| - // 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 we didn't enter a modal loop, need to unhook the filter.
|
| - if (handle_event_message_filter_hook_) {
|
| - UnhookWindowsHookEx(handle_event_message_filter_hook_);
|
| - handle_event_message_filter_hook_ = NULL;
|
| - }
|
| -
|
| - if (::IsWindow(last_focus_window)) {
|
| - // Restore the nestable tasks allowed state in the message loop and reset
|
| - // the os modal loop state as the plugin returned from the TrackPopupMenu
|
| - // API call.
|
| - base::MessageLoop::current()->SetNestableTasksAllowed(
|
| - old_task_reentrancy_state);
|
| - base::MessageLoop::current()->set_os_modal_loop(false);
|
| - // The Flash plugin at times sets focus to its hidden top level window
|
| - // with class name SWFlash_PlaceholderX. This causes the chrome browser
|
| - // window to receive a WM_ACTIVATEAPP message as a top level window from
|
| - // another thread is now active. We end up in a state where the chrome
|
| - // browser window is not active even though the user clicked on it.
|
| - // Our workaround for this is to send over a raw
|
| - // WM_LBUTTONDOWN/WM_LBUTTONUP combination to the last focus window, which
|
| - // does the trick.
|
| - if (dummy_window_for_activation_ != ::GetFocus()) {
|
| - INPUT input_info = {0};
|
| - input_info.type = INPUT_MOUSE;
|
| - input_info.mi.dwFlags = MOUSEEVENTF_LEFTDOWN;
|
| - ::SendInput(1, &input_info, sizeof(INPUT));
|
| -
|
| - input_info.type = INPUT_MOUSE;
|
| - input_info.mi.dwFlags = MOUSEEVENTF_LEFTUP;
|
| - ::SendInput(1, &input_info, sizeof(INPUT));
|
| - } else {
|
| - ::SetFocus(last_focus_window);
|
| - }
|
| - }
|
| return ret;
|
| }
|
|
|
| -
|
| -void WebPluginDelegateImpl::OnModalLoopEntered() {
|
| - DCHECK(handle_event_pump_messages_event_ != NULL);
|
| - SetEvent(handle_event_pump_messages_event_);
|
| -
|
| - base::MessageLoop::current()->SetNestableTasksAllowed(true);
|
| - base::MessageLoop::current()->set_os_modal_loop(true);
|
| -
|
| - UnhookWindowsHookEx(handle_event_message_filter_hook_);
|
| - handle_event_message_filter_hook_ = NULL;
|
| -}
|
| -
|
| -bool WebPluginDelegateImpl::ShouldTrackEventForModalLoops(NPEvent* event) {
|
| - if (event->event == WM_RBUTTONDOWN)
|
| - return true;
|
| - return false;
|
| -}
|
| -
|
| -BOOL WINAPI WebPluginDelegateImpl::TrackPopupMenuPatch(
|
| - HMENU menu, unsigned int flags, int x, int y, int reserved,
|
| - HWND window, const RECT* rect) {
|
| -
|
| - if (g_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) {
|
| - bool valid =
|
| - GetParent(g_current_plugin_instance->dummy_window_for_activation_) !=
|
| - GetDesktopWindow();
|
| - if (valid) {
|
| - window = g_current_plugin_instance->dummy_window_for_activation_;
|
| - } else {
|
| - NOTREACHED() << "Dummy window not parented";
|
| - }
|
| - }
|
| - }
|
| -
|
| - BOOL result = TrackPopupMenu(menu, flags, x, y, reserved, window, rect);
|
| - return result;
|
| -}
|
| -
|
| -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 (!g_current_plugin_instance) {
|
| - HCURSOR current_cursor = GetCursor();
|
| - if (current_cursor != cursor) {
|
| - ::SetCursor(cursor);
|
| - }
|
| - return current_cursor;
|
| - }
|
| - return ::SetCursor(cursor);
|
| -}
|
| -
|
| -LONG WINAPI WebPluginDelegateImpl::RegEnumKeyExWPatch(
|
| - HKEY key, DWORD index, LPWSTR name, LPDWORD name_size, LPDWORD reserved,
|
| - LPWSTR class_name, LPDWORD class_size, PFILETIME last_write_time) {
|
| - DWORD orig_size = *name_size;
|
| - LONG rv = RegEnumKeyExW(key, index, name, name_size, reserved, class_name,
|
| - class_size, last_write_time);
|
| - if (rv == ERROR_SUCCESS &&
|
| - GetKeyPath(key).find(L"Microsoft\\MediaPlayer\\ShimInclusionList") !=
|
| - std::wstring::npos) {
|
| - static const wchar_t kChromeExeName[] = L"chrome.exe";
|
| - wcsncpy_s(name, orig_size, kChromeExeName, arraysize(kChromeExeName));
|
| - *name_size =
|
| - std::min(orig_size, static_cast<DWORD>(arraysize(kChromeExeName)));
|
| - }
|
| -
|
| - return rv;
|
| -}
|
| -
|
| -void WebPluginDelegateImpl::ImeCompositionUpdated(
|
| - const base::string16& text,
|
| - const std::vector<int>& clauses,
|
| - const std::vector<int>& target,
|
| - int cursor_position) {
|
| - if (!plugin_ime_)
|
| - plugin_ime_.reset(new WebPluginIMEWin);
|
| -
|
| - plugin_ime_->CompositionUpdated(text, clauses, target, cursor_position);
|
| - plugin_ime_->SendEvents(instance());
|
| -}
|
| -
|
| -void WebPluginDelegateImpl::ImeCompositionCompleted(
|
| - const base::string16& text) {
|
| - if (!plugin_ime_)
|
| - plugin_ime_.reset(new WebPluginIMEWin);
|
| - plugin_ime_->CompositionCompleted(text);
|
| - plugin_ime_->SendEvents(instance());
|
| -}
|
| -
|
| -bool WebPluginDelegateImpl::GetIMEStatus(int* input_type,
|
| - gfx::Rect* caret_rect) {
|
| - if (!plugin_ime_)
|
| - return false;
|
| - return plugin_ime_->GetStatus(input_type, caret_rect);
|
| -}
|
| -
|
| -// static
|
| -FARPROC WINAPI WebPluginDelegateImpl::GetProcAddressPatch(HMODULE module,
|
| - LPCSTR name) {
|
| - FARPROC imm_function = WebPluginIMEWin::GetProcAddress(name);
|
| - if (imm_function)
|
| - return imm_function;
|
| - return ::GetProcAddress(module, name);
|
| -}
|
| -
|
| -HWND WINAPI WebPluginDelegateImpl::WindowFromPointPatch(POINT point) {
|
| - HWND window = WindowFromPoint(point);
|
| - if (::ScreenToClient(window, &point)) {
|
| - HWND child = ChildWindowFromPoint(window, point);
|
| - if (::IsWindow(child) &&
|
| - ::GetProp(child, content::kPluginDummyParentProperty))
|
| - return child;
|
| - }
|
| - return window;
|
| -}
|
| -
|
| } // namespace content
|
|
|