/*

 * Copyright (C) 2005, 2006, 2007 Apple 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. 

 * 3.  Neither the name of Apple Computer, Inc. ("Apple") nor the names of

 *     its contributors may be used to endorse or promote products derived

 *     from this software without specific prior written permission. 

 *

 * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "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 OR ITS 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.

 */

#if ENABLE(NETSCAPE_PLUGIN_API)

#import "WebNetscapePluginView.h"

#import "WebDataSourceInternal.h"

#import "WebDefaultUIDelegate.h"

#import "WebFrameInternal.h" 

#import "WebFrameView.h"

#import "WebKitErrorsPrivate.h"

#import "WebKitLogging.h"

#import "WebKitNSStringExtras.h"

#import "WebKitSystemInterface.h"

#import "WebNSDataExtras.h"

#import "WebNSDictionaryExtras.h"

#import "WebNSObjectExtras.h"

#import "WebNSURLExtras.h"

#import "WebNSURLRequestExtras.h"

#import "WebNSViewExtras.h"

#import "WebNetscapeContainerCheckContextInfo.h"

#import "WebNetscapeContainerCheckPrivate.h"

#import "WebNetscapePluginEventHandler.h"

#import "WebNetscapePluginPackage.h"

#import "WebNetscapePluginStream.h"

#import "WebPluginContainerCheck.h"

#import "WebPluginRequest.h"

#import "WebPreferences.h"

#import "WebUIDelegatePrivate.h"

#import "WebViewInternal.h"

#import <Carbon/Carbon.h>

#import <WebCore/CookieJar.h>

#import <WebCore/DocumentLoader.h>

#import <WebCore/Element.h>

#import <WebCore/Frame.h> 

#import <WebCore/FrameLoader.h> 

#import <WebCore/FrameTree.h>

#import <WebCore/FrameView.h>

#import <WebCore/HTMLPlugInElement.h>

#import <WebCore/Page.h> 

#import <WebCore/PluginMainThreadScheduler.h>

#import <WebCore/ScriptController.h>

#import <WebCore/SecurityOrigin.h>

#import <WebCore/SoftLinking.h> 

#import <WebCore/WebCoreObjCExtras.h>

#import <WebCore/WebCoreURLResponse.h>

#import <WebCore/npruntime_impl.h>

#import <WebKit/DOMPrivate.h>

#import <WebKit/WebUIDelegate.h>

#import <objc/objc-runtime.h>

#import <runtime/InitializeThreading.h>

#import <runtime/JSLock.h>

#import <wtf/Assertions.h>

#import <wtf/Threading.h>

#import <wtf/text/CString.h>

#define LoginWindowDidSwitchFromUserNotification    @"WebLoginWindowDidSwitchFromUserNotification"

#define LoginWindowDidSwitchToUserNotification      @"WebLoginWindowDidSwitchToUserNotification"

#define WKNVSupportsCompositingCoreAnimationPluginsBool 74656  /* TRUE if the browser supports hardware compositing of Core Animation plug-ins  */

static const int WKNVSilverlightFullscreenPerformanceIssueFixed = 7288546; /* TRUE if Siverlight addressed its underlying  bug in <rdar://problem/7288546> */

using namespace WebCore;

using namespace WebKit;

using namespace std;

static inline bool isDrawingModelQuickDraw(NPDrawingModel drawingModel)

{

#ifndef NP_NO_QUICKDRAW

    return drawingModel == NPDrawingModelQuickDraw;

#else

    return false;

#endif

};

@interface WebNetscapePluginView (Internal)

- (NPError)_createPlugin;

- (void)_destroyPlugin;

- (NSBitmapImageRep *)_printedPluginBitmap;

- (void)_redeliverStream;

- (BOOL)_shouldCancelSrcStream;

@end

static WebNetscapePluginView *currentPluginView = nil;

typedef struct OpaquePortState* PortState;

static const double ThrottledTimerInterval = 0.25;

class PluginTimer : public TimerBase {

public:

    typedef void (*TimerFunc)(NPP npp, uint32_t timerID);

    PluginTimer(NPP npp, uint32_t timerID, uint32_t interval, NPBool repeat, TimerFunc timerFunc)

        : m_npp(npp)

        , m_timerID(timerID)

        , m_interval(interval)

        , m_repeat(repeat)

        , m_timerFunc(timerFunc)

    {

    }

    void start(bool throttle)

    {

        ASSERT(!isActive());

        double timeInterval = m_interval / 1000.0;

        if (throttle)

            timeInterval = max(timeInterval, ThrottledTimerInterval);

        if (m_repeat)

            startRepeating(timeInterval);

        else

            startOneShot(timeInterval);

    }

private:

    virtual void fired() 

    {

        m_timerFunc(m_npp, m_timerID);

        if (!m_repeat)

            delete this;

    }

    NPP m_npp;

    uint32_t m_timerID;

    uint32_t m_interval;

    NPBool m_repeat;

    TimerFunc m_timerFunc;

};

#ifndef NP_NO_QUICKDRAW

// QuickDraw is not available in 64-bit

typedef struct {

    GrafPtr oldPort;

    GDHandle oldDevice;

    Point oldOrigin;

    RgnHandle oldClipRegion;

    RgnHandle oldVisibleRegion;

    RgnHandle clipRegion;

    BOOL forUpdate;

} PortState_QD;

#endif /* NP_NO_QUICKDRAW */

typedef struct {

    CGContextRef context;

} PortState_CG;

@class NSTextInputContext;

@interface NSResponder (AppKitDetails)

- (NSTextInputContext *)inputContext;

@end

@interface WebNetscapePluginView (ForwardDeclarations)

- (void)setWindowIfNecessary;

- (NPError)loadRequest:(NSMutableURLRequest *)request inTarget:(const char *)cTarget withNotifyData:(void *)notifyData sendNotification:(BOOL)sendNotification;

@end

@implementation WebNetscapePluginView

+ (void)initialize

{

    JSC::initializeThreading();

    WTF::initializeMainThreadToProcessMainThread();

#ifndef BUILDING_ON_TIGER

    WebCoreObjCFinalizeOnMainThread(self);

#endif

    WKSendUserChangeNotifications();

}

#pragma mark EVENTS

// The WindowRef created by -[NSWindow windowRef] has a QuickDraw GrafPort that covers 

// the entire window frame (or structure region to use the Carbon term) rather then just the window content.

// We can remove this when <rdar://problem/4201099> is fixed.

- (void)fixWindowPort

{

#ifndef NP_NO_QUICKDRAW

    ASSERT(isDrawingModelQuickDraw(drawingModel));

    NSWindow *currentWindow = [self currentWindow];

    if ([currentWindow isKindOfClass:objc_getClass("NSCarbonWindow")])

        return;

    float windowHeight = [currentWindow frame].size.height;

    NSView *contentView = [currentWindow contentView];

    NSRect contentRect = [contentView convertRect:[contentView frame] toView:nil]; // convert to window-relative coordinates

    CGrafPtr oldPort;

    GetPort(&oldPort);    

    SetPort(GetWindowPort((WindowRef)[currentWindow windowRef]));

    MovePortTo(static_cast<short>(contentRect.origin.x), /* Flip Y */ static_cast<short>(windowHeight - NSMaxY(contentRect)));

    PortSize(static_cast<short>(contentRect.size.width), static_cast<short>(contentRect.size.height));

    SetPort(oldPort);

#endif

}

#ifndef NP_NO_QUICKDRAW

static UInt32 getQDPixelFormatForBitmapContext(CGContextRef context)

{

    UInt32 byteOrder = CGBitmapContextGetBitmapInfo(context) & kCGBitmapByteOrderMask;

    if (byteOrder == kCGBitmapByteOrderDefault)

        switch (CGBitmapContextGetBitsPerPixel(context)) {

            case 16:

                byteOrder = kCGBitmapByteOrder16Host;

                break;

            case 32:

                byteOrder = kCGBitmapByteOrder32Host;

                break;

        }

    switch (byteOrder) {

        case kCGBitmapByteOrder16Little:

            return k16LE555PixelFormat;

        case kCGBitmapByteOrder32Little:

            return k32BGRAPixelFormat;

        case kCGBitmapByteOrder16Big:

            return k16BE555PixelFormat;

        case kCGBitmapByteOrder32Big:

            return k32ARGBPixelFormat;

    }

    ASSERT_NOT_REACHED();

    return 0;

}

static inline void getNPRect(const CGRect& cgr, NPRect& npr)

{

    npr.top = static_cast<uint16_t>(cgr.origin.y);

    npr.left = static_cast<uint16_t>(cgr.origin.x);

    npr.bottom = static_cast<uint16_t>(CGRectGetMaxY(cgr));

    npr.right = static_cast<uint16_t>(CGRectGetMaxX(cgr));

}

#endif

static inline void getNPRect(const NSRect& nr, NPRect& npr)

{

    npr.top = static_cast<uint16_t>(nr.origin.y);

    npr.left = static_cast<uint16_t>(nr.origin.x);

    npr.bottom = static_cast<uint16_t>(NSMaxY(nr));

    npr.right = static_cast<uint16_t>(NSMaxX(nr));

}

- (PortState)saveAndSetNewPortStateForUpdate:(BOOL)forUpdate

{

    ASSERT([self currentWindow] != nil);

    // The base coordinates of a window and it's contentView happen to be the equal at a userSpaceScaleFactor

    // of 1. For non-1.0 scale factors this assumption is false.

    NSView *windowContentView = [[self window] contentView];

    NSRect boundsInWindow = [self convertRect:[self bounds] toView:windowContentView];

    NSRect visibleRectInWindow = [self convertRect:[self visibleRect] toView:windowContentView];

    // Flip Y to convert -[NSWindow contentView] coordinates to top-left-based window coordinates.

    float borderViewHeight = [[self currentWindow] frame].size.height;

    boundsInWindow.origin.y = borderViewHeight - NSMaxY(boundsInWindow);

    visibleRectInWindow.origin.y = borderViewHeight - NSMaxY(visibleRectInWindow);

#ifndef NP_NO_QUICKDRAW

    WindowRef windowRef = (WindowRef)[[self currentWindow] windowRef];

    ASSERT(windowRef);

    // Look at the Carbon port to convert top-left-based window coordinates into top-left-based content coordinates.

    if (isDrawingModelQuickDraw(drawingModel)) {

        // If drawing with QuickDraw, fix the window port so that it has the same bounds as the NSWindow's

        // content view.  This makes it easier to convert between AppKit view and QuickDraw port coordinates.

        [self fixWindowPort];

        ::Rect portBounds;

        CGrafPtr port = GetWindowPort(windowRef);

        GetPortBounds(port, &portBounds);

        PixMap *pix = *GetPortPixMap(port);

        boundsInWindow.origin.x += pix->bounds.left - portBounds.left;

        boundsInWindow.origin.y += pix->bounds.top - portBounds.top;

        visibleRectInWindow.origin.x += pix->bounds.left - portBounds.left;

        visibleRectInWindow.origin.y += pix->bounds.top - portBounds.top;

    }

#endif

    window.type = NPWindowTypeWindow;

    window.x = (int32_t)boundsInWindow.origin.x; 

    window.y = (int32_t)boundsInWindow.origin.y;

    window.width = static_cast<uint32_t>(NSWidth(boundsInWindow));

    window.height = static_cast<uint32_t>(NSHeight(boundsInWindow));

    // "Clip-out" the plug-in when:

    // 1) it's not really in a window or off-screen or has no height or width.

    // 2) window.x is a "big negative number" which is how WebCore expresses off-screen widgets.

    // 3) the window is miniaturized or the app is hidden

    // 4) we're inside of viewWillMoveToWindow: with a nil window. In this case, superviews may already have nil 

    // superviews and nil windows and results from convertRect:toView: are incorrect.

    if (window.width <= 0 || window.height <= 0 || window.x < -100000 || [self shouldClipOutPlugin]) {

        // The following code tries to give plug-ins the same size they will eventually have.

        // The specifiedWidth and specifiedHeight variables are used to predict the size that

        // WebCore will eventually resize us to.

        // The QuickTime plug-in has problems if you give it a width or height of 0.

        // Since other plug-ins also might have the same sort of trouble, we make sure

        // to always give plug-ins a size other than 0,0.

        if (window.width <= 0)

            window.width = specifiedWidth > 0 ? specifiedWidth : 100;

        if (window.height <= 0)

            window.height = specifiedHeight > 0 ? specifiedHeight : 100;

        window.clipRect.bottom = window.clipRect.top;

        window.clipRect.left = window.clipRect.right;

        // Core Animation plug-ins need to be updated (with a 0,0,0,0 clipRect) when

        // moved to a background tab. We don't do this for Core Graphics plug-ins as

        // older versions of Flash have historical WebKit-specific code that isn't

        // compatible with this behavior.

        if (drawingModel == NPDrawingModelCoreAnimation)

            getNPRect(NSZeroRect, window.clipRect);

    } else {

        getNPRect(visibleRectInWindow, window.clipRect);

    }

    // Save the port state, set up the port for entry into the plugin

    PortState portState;

    switch (drawingModel) {

#ifndef NP_NO_QUICKDRAW

        case NPDrawingModelQuickDraw: {

            // Set up NS_Port.

            ::Rect portBounds;

            CGrafPtr port = GetWindowPort(windowRef);

            GetPortBounds(port, &portBounds);

            nPort.qdPort.port = port;

            nPort.qdPort.portx = (int32_t)-boundsInWindow.origin.x;

            nPort.qdPort.porty = (int32_t)-boundsInWindow.origin.y;

            window.window = &nPort;

            PortState_QD *qdPortState = (PortState_QD*)malloc(sizeof(PortState_QD));

            portState = (PortState)qdPortState;

            GetGWorld(&qdPortState->oldPort, &qdPortState->oldDevice);    

            qdPortState->oldOrigin.h = portBounds.left;

            qdPortState->oldOrigin.v = portBounds.top;

            qdPortState->oldClipRegion = NewRgn();

            GetPortClipRegion(port, qdPortState->oldClipRegion);

            qdPortState->oldVisibleRegion = NewRgn();

            GetPortVisibleRegion(port, qdPortState->oldVisibleRegion);

            RgnHandle clipRegion = NewRgn();

            qdPortState->clipRegion = clipRegion;

            CGContextRef currentContext = (CGContextRef)[[NSGraphicsContext currentContext] graphicsPort];

            if (currentContext && WKCGContextIsBitmapContext(currentContext)) {

                // We use WKCGContextIsBitmapContext here, because if we just called CGBitmapContextGetData

                // on any context, we'd log to the console every time. But even if WKCGContextIsBitmapContext

                // returns true, it still might not be a context we need to create a GWorld for; for example

                // transparency layers will return true, but return 0 for CGBitmapContextGetData.

                void* offscreenData = CGBitmapContextGetData(currentContext);

                if (offscreenData) {

                    // If the current context is an offscreen bitmap, then create a GWorld for it.

                    ::Rect offscreenBounds;

                    offscreenBounds.top = 0;

                    offscreenBounds.left = 0;

                    offscreenBounds.right = CGBitmapContextGetWidth(currentContext);

                    offscreenBounds.bottom = CGBitmapContextGetHeight(currentContext);

                    GWorldPtr newOffscreenGWorld;

                    QDErr err = NewGWorldFromPtr(&newOffscreenGWorld,

                        getQDPixelFormatForBitmapContext(currentContext), &offscreenBounds, 0, 0, 0,

                        static_cast<char*>(offscreenData), CGBitmapContextGetBytesPerRow(currentContext));

                    ASSERT(newOffscreenGWorld);

                    ASSERT(!err);

                    if (!err) {

                        if (offscreenGWorld)

                            DisposeGWorld(offscreenGWorld);

                        offscreenGWorld = newOffscreenGWorld;

                        SetGWorld(offscreenGWorld, NULL);

                        port = offscreenGWorld;

                        nPort.qdPort.port = port;

                        boundsInWindow = [self bounds];

                        // Generate a QD origin based on the current affine transform for currentContext.

                        CGAffineTransform offscreenMatrix = CGContextGetCTM(currentContext);

                        CGPoint origin = {0,0};

                        CGPoint axisFlip = {1,1};

                        origin = CGPointApplyAffineTransform(origin, offscreenMatrix);

                        axisFlip = CGPointApplyAffineTransform(axisFlip, offscreenMatrix);

                        // Quartz bitmaps have origins at the bottom left, but the axes may be inverted, so handle that.

                        origin.x = offscreenBounds.left - origin.x * (axisFlip.x - origin.x);

                        origin.y = offscreenBounds.bottom + origin.y * (axisFlip.y - origin.y);

                        nPort.qdPort.portx = static_cast<int32_t>(-boundsInWindow.origin.x + origin.x);

                        nPort.qdPort.porty = static_cast<int32_t>(-boundsInWindow.origin.y - origin.y);

                        window.x = 0;

                        window.y = 0;

                        window.window = &nPort;

                        // Use the clip bounds from the context instead of the bounds we created

                        // from the window above.

                        getNPRect(CGRectOffset(CGContextGetClipBoundingBox(currentContext), -origin.x, origin.y), window.clipRect);

                    }

                }

            }

            MacSetRectRgn(clipRegion,

                window.clipRect.left + nPort.qdPort.portx, window.clipRect.top + nPort.qdPort.porty,

                window.clipRect.right + nPort.qdPort.portx, window.clipRect.bottom + nPort.qdPort.porty);

            // Clip to the dirty region if drawing to a window. When drawing to another bitmap context, do not clip.

            if ([NSGraphicsContext currentContext] == [[self currentWindow] graphicsContext]) {

                // Clip to dirty region so plug-in does not draw over already-drawn regions of the window that are

                // not going to be redrawn this update.  This forces plug-ins to play nice with z-index ordering.

                if (forUpdate) {

                    RgnHandle viewClipRegion = NewRgn();

                    // Get list of dirty rects from the opaque ancestor -- WebKit does some tricks with invalidation and

                    // display to enable z-ordering for NSViews; a side-effect of this is that only the WebHTMLView

                    // knows about the true set of dirty rects.

                    NSView *opaqueAncestor = [self opaqueAncestor];

                    const NSRect *dirtyRects;

                    NSInteger dirtyRectCount, dirtyRectIndex;

                    [opaqueAncestor getRectsBeingDrawn:&dirtyRects count:&dirtyRectCount];

                    for (dirtyRectIndex = 0; dirtyRectIndex < dirtyRectCount; dirtyRectIndex++) {

                        NSRect dirtyRect = [self convertRect:dirtyRects[dirtyRectIndex] fromView:opaqueAncestor];

                        if (!NSEqualSizes(dirtyRect.size, NSZeroSize)) {

                            // Create a region for this dirty rect

                            RgnHandle dirtyRectRegion = NewRgn();

                            SetRectRgn(dirtyRectRegion, static_cast<short>(NSMinX(dirtyRect)), static_cast<short>(NSMinY(dirtyRect)), static_cast<short>(NSMaxX(dirtyRect)), static_cast<short>(NSMaxY(dirtyRect)));

                            // Union this dirty rect with the rest of the dirty rects

                            UnionRgn(viewClipRegion, dirtyRectRegion, viewClipRegion);

                            DisposeRgn(dirtyRectRegion);

                        }

                    }

                    // Intersect the dirty region with the clip region, so that we only draw over dirty parts

                    SectRgn(clipRegion, viewClipRegion, clipRegion);

                    DisposeRgn(viewClipRegion);

                }

            }

            // Switch to the port and set it up.

            SetPort(port);

            PenNormal();

            ForeColor(blackColor);

            BackColor(whiteColor);

            SetOrigin(nPort.qdPort.portx, nPort.qdPort.porty);

            SetPortClipRegion(nPort.qdPort.port, clipRegion);

            if (forUpdate) {

                // AppKit may have tried to help us by doing a BeginUpdate.

                // But the invalid region at that level didn't include AppKit's notion of what was not valid.

                // We reset the port's visible region to counteract what BeginUpdate did.

                SetPortVisibleRegion(nPort.qdPort.port, clipRegion);

                InvalWindowRgn(windowRef, clipRegion);

            }

            qdPortState->forUpdate = forUpdate;

            break;

        }

#endif /* NP_NO_QUICKDRAW */

        case NPDrawingModelCoreGraphics: {            

            if (![self canDraw]) {

                portState = NULL;

                break;

            }

            ASSERT([NSView focusView] == self);

            CGContextRef context = static_cast<CGContextRef>([[NSGraphicsContext currentContext] graphicsPort]);

            PortState_CG *cgPortState = (PortState_CG *)malloc(sizeof(PortState_CG));

            portState = (PortState)cgPortState;

            cgPortState->context = context;

#ifndef NP_NO_CARBON            

            if (eventModel != NPEventModelCocoa) {

                // Update the plugin's window/context

                nPort.cgPort.window = windowRef;

                nPort.cgPort.context = context;

                window.window = &nPort.cgPort;

            }                

#endif /* NP_NO_CARBON */

            // Save current graphics context's state; will be restored by -restorePortState:

            CGContextSaveGState(context);

            // Clip to the dirty region if drawing to a window. When drawing to another bitmap context, do not clip.

            if ([NSGraphicsContext currentContext] == [[self currentWindow] graphicsContext]) {

                // Get list of dirty rects from the opaque ancestor -- WebKit does some tricks with invalidation and

                // display to enable z-ordering for NSViews; a side-effect of this is that only the WebHTMLView

                // knows about the true set of dirty rects.

                NSView *opaqueAncestor = [self opaqueAncestor];

                const NSRect *dirtyRects;