/*

 * 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.

 */

#ifndef __LP64__

#import "WebBaseNetscapePluginView.h"

#import "WebDataSourceInternal.h"

#import "WebDefaultUIDelegate.h"

#import "WebFrameBridge.h"

#import "WebFrameInternal.h" 

#import "WebFrameView.h"

#import "WebGraphicsExtras.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 "WebNetscapePluginPackage.h"

#import "WebNetscapePluginStream.h"

#import "WebNullPluginView.h"

#import "WebPreferences.h"

#import "WebViewInternal.h"

#import <Carbon/Carbon.h>

#import <JavaScriptCore/Assertions.h>

#import <JavaScriptCore/JSLock.h>

#import <JavaScriptCore/npruntime_impl.h>

#import <WebCore/Document.h>

#import <WebCore/Element.h>

#import <WebCore/Frame.h> 

#import <WebCore/FrameLoader.h> 

#import <WebCore/FrameTree.h> 

#import <WebCore/Page.h> 

#import <WebCore/SoftLinking.h> 

#import <WebCore/WebCoreObjCExtras.h>

#import <WebKit/DOMPrivate.h>

#import <WebKit/WebUIDelegate.h>

#import <objc/objc-runtime.h>

using namespace WebCore;

// Send null events 50 times a second when active, so plug-ins like Flash get high frame rates.

#define NullEventIntervalActive         0.02

#define NullEventIntervalNotActive      0.25

#define LoginWindowDidSwitchFromUserNotification    @"WebLoginWindowDidSwitchFromUserNotification"

#define LoginWindowDidSwitchToUserNotification      @"WebLoginWindowDidSwitchToUserNotification"

SOFT_LINK_FRAMEWORK(OpenGL)

SOFT_LINK_FRAMEWORK(AGL)

SOFT_LINK(OpenGL, CGLGetOffScreen, CGLError, (CGLContextObj ctx, GLsizei *width, GLsizei *height, GLint *rowbytes, void **baseaddr), (ctx, width, height, rowbytes, baseaddr))

SOFT_LINK(OpenGL, CGLSetOffScreen, CGLError, (CGLContextObj ctx, GLsizei width, GLsizei height, GLint rowbytes, void *baseaddr), (ctx, width, height, rowbytes, baseaddr))

SOFT_LINK(OpenGL, glViewport, void, (GLint x, GLint y, GLsizei width, GLsizei height), (x, y, width, height))

SOFT_LINK(AGL, aglCreateContext, AGLContext, (AGLPixelFormat pix, AGLContext share), (pix, share))

SOFT_LINK(AGL, aglSetWindowRef, GLboolean, (AGLContext ctx, WindowRef window), (ctx, window))

SOFT_LINK(AGL, aglSetDrawable, GLboolean, (AGLContext ctx, AGLDrawable draw), (ctx, draw))

#ifndef BUILDING_ON_TIGER

SOFT_LINK(AGL, aglChoosePixelFormat, AGLPixelFormat, (const void *gdevs, GLint ndev, const GLint *attribs), (gdevs, ndev, attribs))

#else

SOFT_LINK(AGL, aglChoosePixelFormat, AGLPixelFormat, (const AGLDevice *gdevs, GLint ndev, const GLint *attribs), (gdevs, ndev, attribs))

#endif

SOFT_LINK(AGL, aglDestroyPixelFormat, void, (AGLPixelFormat pix), (pix))

SOFT_LINK(AGL, aglDestroyContext, GLboolean, (AGLContext ctx), (ctx))

SOFT_LINK(AGL, aglGetCGLContext, GLboolean, (AGLContext ctx, void **cgl_ctx), (ctx, cgl_ctx))

SOFT_LINK(AGL, aglGetCurrentContext, AGLContext, (void), ())

SOFT_LINK(AGL, aglSetCurrentContext, GLboolean, (AGLContext ctx), (ctx))

SOFT_LINK(AGL, aglGetError, GLenum, (void), ())

SOFT_LINK(AGL, aglUpdateContext, GLboolean, (AGLContext ctx), (ctx))

SOFT_LINK(AGL, aglErrorString, const GLubyte *, (GLenum code), (code))

@interface WebBaseNetscapePluginView (Internal)

- (void)_viewHasMoved;

- (NPError)_createPlugin;

- (void)_destroyPlugin;

- (NSBitmapImageRep *)_printedPluginBitmap;

- (BOOL)_createAGLContextIfNeeded;

- (BOOL)_createWindowedAGLContext;

- (BOOL)_createWindowlessAGLContext;

- (CGLContextObj)_cglContext;

- (BOOL)_getAGLOffscreenBuffer:(GLvoid **)outBuffer width:(GLsizei *)outWidth height:(GLsizei *)outHeight;

- (void)_destroyAGLContext;

- (void)_reshapeAGLWindow;

- (void)_hideAGLWindow;

- (NSImage *)_aglOffscreenImageForDrawingInRect:(NSRect)drawingInRect;

- (void)_redeliverStream;

@end

static WebBaseNetscapePluginView *currentPluginView = nil;

typedef struct OpaquePortState* PortState;

#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;

typedef struct {

    AGLContext oldContext;

} PortState_GL;

@interface WebPluginRequest : NSObject

{

    NSURLRequest *_request;

    NSString *_frameName;

    void *_notifyData;

    BOOL _didStartFromUserGesture;

    BOOL _sendNotification;

}

- (id)initWithRequest:(NSURLRequest *)request frameName:(NSString *)frameName notifyData:(void *)notifyData sendNotification:(BOOL)sendNotification didStartFromUserGesture:(BOOL)currentEventIsUserGesture;

- (NSURLRequest *)request;

- (NSString *)frameName;

- (void *)notifyData;

- (BOOL)isCurrentEventUserGesture;

- (BOOL)sendNotification;

@end

@interface NSData (WebPluginDataExtras)

- (BOOL)_web_startsWithBlankLine;

- (NSInteger)_web_locationAfterFirstBlankLine;

@end

static OSStatus TSMEventHandler(EventHandlerCallRef inHandlerRef, EventRef inEvent, void *pluginView);

@interface WebBaseNetscapePluginView (ForwardDeclarations)

- (void)setWindowIfNecessary;

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

@end

@implementation WebBaseNetscapePluginView

+ (void)initialize

{

#ifndef BUILDING_ON_TIGER

    WebCoreObjCFinalizeOnMainThread(self);

#endif

    WKSendUserChangeNotifications();

}

#pragma mark EVENTS

+ (void)getCarbonEvent:(EventRecord *)carbonEvent

{

    carbonEvent->what = nullEvent;

    carbonEvent->message = 0;

    carbonEvent->when = TickCount();

    GetGlobalMouse(&carbonEvent->where);

    carbonEvent->where.h = static_cast<short>(carbonEvent->where.h * HIGetScaleFactor());

    carbonEvent->where.v = static_cast<short>(carbonEvent->where.v * HIGetScaleFactor());

    carbonEvent->modifiers = GetCurrentKeyModifiers();

    if (!Button())

        carbonEvent->modifiers |= btnState;

}

- (void)getCarbonEvent:(EventRecord *)carbonEvent

{

    [[self class] getCarbonEvent:carbonEvent];

}

- (EventModifiers)modifiersForEvent:(NSEvent *)event

{

    EventModifiers modifiers;

    unsigned int modifierFlags = [event modifierFlags];

    NSEventType eventType = [event type];

    modifiers = 0;

    if (eventType != NSLeftMouseDown && eventType != NSRightMouseDown)

        modifiers |= btnState;

    if (modifierFlags & NSCommandKeyMask)

        modifiers |= cmdKey;

    if (modifierFlags & NSShiftKeyMask)

        modifiers |= shiftKey;

    if (modifierFlags & NSAlphaShiftKeyMask)

        modifiers |= alphaLock;

    if (modifierFlags & NSAlternateKeyMask)

        modifiers |= optionKey;

    if (modifierFlags & NSControlKeyMask || eventType == NSRightMouseDown)

        modifiers |= controlKey;

    return modifiers;

}

- (void)getCarbonEvent:(EventRecord *)carbonEvent withEvent:(NSEvent *)cocoaEvent

{

    if (WKConvertNSEventToCarbonEvent(carbonEvent, cocoaEvent)) {

        carbonEvent->where.h = static_cast<short>(carbonEvent->where.h * HIGetScaleFactor());

        carbonEvent->where.v = static_cast<short>(carbonEvent->where.v * HIGetScaleFactor());

        return;

    }

    NSPoint where = [[cocoaEvent window] convertBaseToScreen:[cocoaEvent locationInWindow]];

    carbonEvent->what = nullEvent;

    carbonEvent->message = 0;

    carbonEvent->when = (UInt32)([cocoaEvent timestamp] * 60); // seconds to ticks

    carbonEvent->where.h = (short)where.x;

    carbonEvent->where.v = (short)(NSMaxY([[[NSScreen screens] objectAtIndex:0] frame]) - where.y);

    carbonEvent->modifiers = [self modifiersForEvent:cocoaEvent];

}

- (BOOL)superviewsHaveSuperviews

{

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

    NSView *view;

    for (view = self; view != nil; view = [view superview]) { 

        if (view == contentView) {

            return YES;

        }

    }

    return NO;

}

#ifndef NP_NO_QUICKDRAW

// 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

{

    ASSERT(drawingModel == NPDrawingModelQuickDraw);

    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);

}

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>(cgr.origin.y);

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

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

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

}

#endif

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

{

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

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

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

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

}

- (NSRect)visibleRect

{

    // WebCore may impose an additional clip (via CSS overflow or clip properties).  Fetch

    // that clip now.    

    return NSIntersectionRect([self convertRect:[element _windowClipRect] fromView:nil], [super visibleRect]);

}

- (PortState)saveAndSetNewPortStateForUpdate:(BOOL)forUpdate

{

    ASSERT([self currentWindow] != nil);

#ifndef NP_NO_QUICKDRAW

    // 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.

    if (drawingModel == NPDrawingModelQuickDraw)

        [self fixWindowPort];

#endif

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

    ASSERT(windowRef);

    // Use AppKit to convert view coordinates to NSWindow coordinates.

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

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

    // Flip Y to convert NSWindow 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

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

    if (drawingModel == NPDrawingModelQuickDraw) {

        ::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.x = (int32)boundsInWindow.origin.x; 

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

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

    window.height = static_cast<uint32>(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.

    NSWindow *realWindow = [self window];

    if (window.width <= 0 || window.height <= 0 || window.x < -100000

            || realWindow == nil || [realWindow isMiniaturized]

            || [NSApp isHidden]

            || ![self superviewsHaveSuperviews]

            || [self isHiddenOrHasHiddenAncestor]) {

        // 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;

    } 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)-boundsInWindow.origin.x;

            nPort.qdPort.porty = (int32)-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 && !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>(-boundsInWindow.origin.x + origin.x);

                        nPort.qdPort.porty = static_cast<int32>(-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(CGContextGetClipBoundingBox(currentContext), 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 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)));