/*

 * Copyright (C) 2006, 2007, 2008 Apple Inc. All rights reserved.

 * Copyright (C) 2008 Collabora Ltd. All rights reserved.

 * Copyright (C) 2008-2009 Torch Mobile, Inc. All rights reserved.

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions

 * are met:

 * 1. Redistributions of source code must retain the above copyright

 *    notice, this list of conditions and the following disclaimer.

 * 2. Redistributions in binary form must reproduce the above copyright

 *    notice, this list of conditions and the following disclaimer in the

 *    documentation and/or other materials provided with the distribution.

 *

 * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY

 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR

 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR

 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,

 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,

 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR

 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY

 * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 

 */

#include "config.h"

#include "PluginView.h"

#include "BitmapImage.h"

#include "Bridge.h"

#include "Chrome.h"

#include "ChromeClient.h"

#include "Document.h"

#include "DocumentLoader.h"

#include "Element.h"

#include "EventNames.h"

#include "FocusController.h"

#include "Frame.h"

#include "FrameLoadRequest.h"

#include "FrameLoader.h"

#include "FrameTree.h"

#include "FrameView.h"

#include "GraphicsContext.h"

#include "HTMLNames.h"

#include "HTMLPlugInElement.h"

#include "HostWindow.h"

#include "Image.h"

#include "JSDOMBinding.h"

#include "JSDOMWindow.h"

#include "KeyboardEvent.h"

#include "MIMETypeRegistry.h"

#include "MouseEvent.h"

#include "Page.h"

#include "PlatformMouseEvent.h"

#include "PluginDatabase.h"

#include "PluginDebug.h"

#include "PluginMainThreadScheduler.h"

#include "PluginMessageThrottlerWin.h"

#include "PluginPackage.h"

#include "RenderWidget.h"

#include "ScriptController.h"

#include "Settings.h"

#include "WebCoreInstanceHandle.h"

#include "c_instance.h"

#include "npruntime_impl.h"

#include "runtime_root.h"

#include <runtime/JSLock.h>

#include <runtime/JSValue.h>

#include <wtf/ASCIICType.h>

#if !PLATFORM(WX)

#include "BitmapInfo.h"

#endif

#if OS(WINCE)

#undef LOG_NPERROR

#define LOG_NPERROR(x)

#undef LOG_PLUGIN_NET_ERROR

#define LOG_PLUGIN_NET_ERROR()

#endif

#if PLATFORM(CAIRO)

#include <cairo-win32.h>

#endif

#if PLATFORM(QT)

#include "QWebPageClient.h"

#include <QWidget>

#endif

#if PLATFORM(WX)

#include <wx/defs.h>

#include <wx/window.h>

#endif

static inline HWND windowHandleForPageClient(PlatformPageClient client)

{

#if PLATFORM(QT)

    if (!client)

        return 0;

    if (QWidget* pluginParent = qobject_cast<QWidget*>(client->pluginParent()))

        return pluginParent->winId();

    return 0;

#elif PLATFORM(WX)

    if (!client)

        return 0;

    return (HWND)client->GetHandle();

#else

    return client;

#endif

}

using JSC::ExecState;

using JSC::JSLock;

using JSC::JSObject;

using JSC::UString;

using std::min;

using namespace WTF;

namespace WebCore {

using namespace HTMLNames;

const LPCWSTR kWebPluginViewdowClassName = L"WebPluginView";

const LPCWSTR kWebPluginViewProperty = L"WebPluginViewProperty";

#if !OS(WINCE)

// The code used to hook BeginPaint/EndPaint originally came from

// <http://www.fengyuan.com/article/wmprint.html>.

// Copyright (C) 2000 by Feng Yuan (www.fengyuan.com).

static unsigned beginPaintSysCall;

static BYTE* beginPaint;

static unsigned endPaintSysCall;

static BYTE* endPaint;

typedef HDC (WINAPI *PtrBeginPaint)(HWND, PAINTSTRUCT*);

typedef BOOL (WINAPI *PtrEndPaint)(HWND, const PAINTSTRUCT*);

#if OS(WINDOWS) && CPU(X86_64) && COMPILER(MSVC)

extern "C" HDC __stdcall _HBeginPaint(HWND hWnd, LPPAINTSTRUCT lpPaint);

extern "C" BOOL __stdcall _HEndPaint(HWND hWnd, const PAINTSTRUCT* lpPaint);

#endif

HDC WINAPI PluginView::hookedBeginPaint(HWND hWnd, PAINTSTRUCT* lpPaint)

{

    PluginView* pluginView = reinterpret_cast<PluginView*>(GetProp(hWnd, kWebPluginViewProperty));

    if (pluginView && pluginView->m_wmPrintHDC) {

        // We're secretly handling WM_PRINTCLIENT, so set up the PAINTSTRUCT so

        // that the plugin will paint into the HDC we provide.

        memset(lpPaint, 0, sizeof(PAINTSTRUCT));

        lpPaint->hdc = pluginView->m_wmPrintHDC;

        GetClientRect(hWnd, &lpPaint->rcPaint);

        return pluginView->m_wmPrintHDC;

    }

#if COMPILER(GCC)

    HDC result;

    asm ("push    %2\n"

         "push    %3\n"

         "call    *%4\n"

         : "=a" (result)

         : "a" (beginPaintSysCall), "g" (lpPaint), "g" (hWnd), "m" (beginPaint)

         : "memory"

        );

    return result;

#elif defined(_M_IX86)

    // Call through to the original BeginPaint.

    __asm   mov     eax, beginPaintSysCall

    __asm   push    lpPaint

    __asm   push    hWnd

    __asm   call    beginPaint

#else

    return _HBeginPaint(hWnd, lpPaint);

#endif

}

BOOL WINAPI PluginView::hookedEndPaint(HWND hWnd, const PAINTSTRUCT* lpPaint)

{

    PluginView* pluginView = reinterpret_cast<PluginView*>(GetProp(hWnd, kWebPluginViewProperty));

    if (pluginView && pluginView->m_wmPrintHDC) {

        // We're secretly handling WM_PRINTCLIENT, so we don't have to do any

        // cleanup.

        return TRUE;

    }

#if COMPILER(GCC)

    BOOL result;

    asm ("push   %2\n"

         "push   %3\n"

         "call   *%4\n"

         : "=a" (result)

         : "a" (endPaintSysCall), "g" (lpPaint), "g" (hWnd), "m" (endPaint)

        );

    return result;

#elif defined (_M_IX86)

    // Call through to the original EndPaint.

    __asm   mov     eax, endPaintSysCall

    __asm   push    lpPaint

    __asm   push    hWnd

    __asm   call    endPaint

#else

    return _HEndPaint(hWnd, lpPaint);

#endif

}

static void hook(const char* module, const char* proc, unsigned& sysCallID, BYTE*& pProc, const void* pNewProc)

{

    // See <http://www.fengyuan.com/article/wmprint.html> for an explanation of

    // how this function works.

    HINSTANCE hMod = GetModuleHandleA(module);

    pProc = reinterpret_cast<BYTE*>(reinterpret_cast<ptrdiff_t>(GetProcAddress(hMod, proc)));

#if COMPILER(GCC) || defined(_M_IX86)

    if (pProc[0] != 0xB8)

        return;

    // FIXME: Should we be reading the bytes one-by-one instead of doing an

    // unaligned read?

    sysCallID = *reinterpret_cast<unsigned*>(pProc + 1);

    DWORD flOldProtect;

    if (!VirtualProtect(pProc, 5, PAGE_EXECUTE_READWRITE, &flOldProtect))

        return;

    pProc[0] = 0xE9;

    *reinterpret_cast<unsigned*>(pProc + 1) = reinterpret_cast<intptr_t>(pNewProc) - reinterpret_cast<intptr_t>(pProc + 5);

    pProc += 5;

#else

    /* Disassembly of BeginPaint()

    00000000779FC5B0 4C 8B D1         mov         r10,rcx

    00000000779FC5B3 B8 17 10 00 00   mov         eax,1017h

    00000000779FC5B8 0F 05            syscall

    00000000779FC5BA C3               ret

    00000000779FC5BB 90               nop

    00000000779FC5BC 90               nop

    00000000779FC5BD 90               nop

    00000000779FC5BE 90               nop

    00000000779FC5BF 90               nop

    00000000779FC5C0 90               nop

    00000000779FC5C1 90               nop

    00000000779FC5C2 90               nop

    00000000779FC5C3 90               nop

    */

    // Check for the signature as in the above disassembly

    DWORD guard = 0xB8D18B4C;

    if (*reinterpret_cast<DWORD*>(pProc) != guard)

        return;

    DWORD flOldProtect;

    VirtualProtect(pProc, 12, PAGE_EXECUTE_READWRITE, & flOldProtect);

    pProc[0] = 0x48;    // mov rax, this

    pProc[1] = 0xb8;

    *(__int64*)(pProc+2) = (__int64)pNewProc;

    pProc[10] = 0xff;   // jmp rax

    pProc[11] = 0xe0;

#endif

}

static void setUpOffscreenPaintingHooks(HDC (WINAPI*hookedBeginPaint)(HWND, PAINTSTRUCT*), BOOL (WINAPI*hookedEndPaint)(HWND, const PAINTSTRUCT*))

{

    static bool haveHooked = false;

    if (haveHooked)

        return;

    haveHooked = true;

    // Most (all?) windowed plugins don't seem to respond to WM_PRINTCLIENT, so

    // we hook into BeginPaint/EndPaint to allow their normal WM_PAINT handling

    // to draw into a given HDC. Note that this hooking affects the entire

    // process.

    hook("user32.dll", "BeginPaint", beginPaintSysCall, beginPaint, reinterpret_cast<const void *>(reinterpret_cast<ptrdiff_t>(hookedBeginPaint)));

    hook("user32.dll", "EndPaint", endPaintSysCall, endPaint, reinterpret_cast<const void *>(reinterpret_cast<ptrdiff_t>(hookedEndPaint)));

}

#endif

static bool registerPluginView()

{

    static bool haveRegisteredWindowClass = false;

    if (haveRegisteredWindowClass)

        return true;

    haveRegisteredWindowClass = true;

#if PLATFORM(QT)

    WebCore::setInstanceHandle((HINSTANCE)(qWinAppInst()));

#endif

    ASSERT(WebCore::instanceHandle());

#if OS(WINCE)

    WNDCLASS wcex = { 0 };

#else

    WNDCLASSEX wcex;

    wcex.cbSize = sizeof(WNDCLASSEX);

    wcex.hIconSm        = 0;

#endif

    wcex.style          = CS_DBLCLKS;

#if OS(WINCE)

    wcex.style          |= CS_PARENTDC;

#endif

    wcex.lpfnWndProc    = DefWindowProc;

    wcex.cbClsExtra     = 0;

    wcex.cbWndExtra     = 0;

    wcex.hInstance      = WebCore::instanceHandle();

    wcex.hIcon          = 0;

    wcex.hCursor        = LoadCursor(0, IDC_ARROW);

    wcex.hbrBackground  = (HBRUSH)COLOR_WINDOW;

    wcex.lpszMenuName   = 0;

    wcex.lpszClassName  = kWebPluginViewdowClassName;

#if OS(WINCE)

    return !!RegisterClass(&wcex);

#else

    return !!RegisterClassEx(&wcex);

#endif

}

LRESULT CALLBACK PluginView::PluginViewWndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)

{

    PluginView* pluginView = reinterpret_cast<PluginView*>(GetProp(hWnd, kWebPluginViewProperty));

    return pluginView->wndProc(hWnd, message, wParam, lParam);

}

static bool isWindowsMessageUserGesture(UINT message)

{

    switch (message) {

        case WM_LBUTTONUP:

        case WM_MBUTTONUP:

        case WM_RBUTTONUP:

        case WM_KEYUP:

            return true;

        default:

            return false;

    }

}

LRESULT

PluginView::wndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)

{

    // <rdar://5711136> Sometimes Flash will call SetCapture before creating

    // a full-screen window and will not release it, which causes the

    // full-screen window to never receive mouse events. We set/release capture

    // on mouse down/up before sending the event to the plug-in to prevent that.

    switch (message) {

        case WM_LBUTTONDOWN:

        case WM_MBUTTONDOWN:

        case WM_RBUTTONDOWN:

            ::SetCapture(hWnd);

            break;

        case WM_LBUTTONUP:

        case WM_MBUTTONUP:

        case WM_RBUTTONUP:

            ::ReleaseCapture();

            break;

    }

    if (message == m_lastMessage &&

        m_plugin->quirks().contains(PluginQuirkDontCallWndProcForSameMessageRecursively) && 

        m_isCallingPluginWndProc)

        return 1;

    if (message == WM_USER + 1 &&

        m_plugin->quirks().contains(PluginQuirkThrottleWMUserPlusOneMessages)) {

        if (!m_messageThrottler)

            m_messageThrottler.set(new PluginMessageThrottlerWin(this));

        m_messageThrottler->appendMessage(hWnd, message, wParam, lParam);

        return 0;

    }

    m_lastMessage = message;

    m_isCallingPluginWndProc = true;

    // If the plug-in doesn't explicitly support changing the pop-up state, we enable

    // popups for all user gestures.

    // Note that we need to pop the state in a timer, because the Flash plug-in 

    // pops up windows in response to a posted message.

    if (m_plugin->pluginFuncs()->version < NPVERS_HAS_POPUPS_ENABLED_STATE &&

        isWindowsMessageUserGesture(message) && !m_popPopupsStateTimer.isActive()) {

        pushPopupsEnabledState(true);

        m_popPopupsStateTimer.startOneShot(0);

    }

#if !OS(WINCE)

    if (message == WM_PRINTCLIENT) {

        // Most (all?) windowed plugins don't respond to WM_PRINTCLIENT, so we

        // change the message to WM_PAINT and rely on our hooked versions of

        // BeginPaint/EndPaint to make the plugin draw into the given HDC.

        message = WM_PAINT;

        m_wmPrintHDC = reinterpret_cast<HDC>(wParam);

    }

#endif

    // Call the plug-in's window proc.

    LRESULT result = ::CallWindowProc(m_pluginWndProc, hWnd, message, wParam, lParam);

    m_wmPrintHDC = 0;

    m_isCallingPluginWndProc = false;

    return result;

}

void PluginView::updatePluginWidget()

{

    if (!parent())

        return;

    ASSERT(parent()->isFrameView());

    FrameView* frameView = static_cast<FrameView*>(parent());

    IntRect oldWindowRect = m_windowRect;

    IntRect oldClipRect = m_clipRect;

#if OS(WINCE)

    m_windowRect = frameView->contentsToWindow(frameRect());

#else

    m_windowRect = IntRect(frameView->contentsToWindow(frameRect().location()), frameRect().size());

#endif

    m_clipRect = windowClipRect();

    m_clipRect.move(-m_windowRect.x(), -m_windowRect.y());

    if (platformPluginWidget() && (!m_haveUpdatedPluginWidget || m_windowRect != oldWindowRect || m_clipRect != oldClipRect)) {

        HRGN rgn;

        setCallingPlugin(true);

        // To prevent flashes while scrolling, we disable drawing during the window

        // update process by clipping the window to the zero rect.

        bool clipToZeroRect = !m_plugin->quirks().contains(PluginQuirkDontClipToZeroRectWhenScrolling);

        if (clipToZeroRect) {

            rgn = ::CreateRectRgn(0, 0, 0, 0);

            ::SetWindowRgn(platformPluginWidget(), rgn, FALSE);

        } else {

            rgn = ::CreateRectRgn(m_clipRect.x(), m_clipRect.y(), m_clipRect.right(), m_clipRect.bottom());

            ::SetWindowRgn(platformPluginWidget(), rgn, TRUE);

        }

        if (!m_haveUpdatedPluginWidget || m_windowRect != oldWindowRect)

            ::MoveWindow(platformPluginWidget(), m_windowRect.x(), m_windowRect.y(), m_windowRect.width(), m_windowRect.height(), TRUE);

        if (clipToZeroRect) {

            rgn = ::CreateRectRgn(m_clipRect.x(), m_clipRect.y(), m_clipRect.right(), m_clipRect.bottom());

            ::SetWindowRgn(platformPluginWidget(), rgn, TRUE);

        }

        setCallingPlugin(false);

        m_haveUpdatedPluginWidget = true;

    }

}

void PluginView::setFocus(bool focused)

{

    if (focused && platformPluginWidget())

        SetFocus(platformPluginWidget());

    Widget::setFocus(focused);

}

void PluginView::show()

{

    setSelfVisible(true);

    if (isParentVisible() && platformPluginWidget())

        ShowWindow(platformPluginWidget(), SW_SHOWNA);

    Widget::show();

}

void PluginView::hide()

{

    setSelfVisible(false);

    if (isParentVisible() && platformPluginWidget())

        ShowWindow(platformPluginWidget(), SW_HIDE);

    Widget::hide();

}

bool PluginView::dispatchNPEvent(NPEvent& npEvent)

{

    if (!m_plugin->pluginFuncs()->event)

        return true;

    bool shouldPop = false;

    if (m_plugin->pluginFuncs()->version < NPVERS_HAS_POPUPS_ENABLED_STATE && isWindowsMessageUserGesture(npEvent.event)) {

        pushPopupsEnabledState(true);

        shouldPop = true;

    }

    JSC::JSLock::DropAllLocks dropAllLocks(JSC::SilenceAssertionsOnly);

    setCallingPlugin(true);

    bool result = m_plugin->pluginFuncs()->event(m_instance, &npEvent);

    setCallingPlugin(false);

    if (shouldPop) 

        popPopupsEnabledState();

    return result;

}

void PluginView::paintIntoTransformedContext(HDC hdc)

{

    if (m_isWindowed) {

        SendMessage(platformPluginWidget(), WM_PRINTCLIENT, reinterpret_cast<WPARAM>(hdc), PRF_CLIENT | PRF_CHILDREN | PRF_OWNED);

        return;

    }

    m_npWindow.type = NPWindowTypeDrawable;

    m_npWindow.window = hdc;