1 /*

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

     3  *

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

     5  * modification, are permitted provided that the following conditions

     6  * are met:

     7  *

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

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

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

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

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

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

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

    15  *     from this software without specific prior written permission. 

    16  *

    17  * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY

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

    19  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE

    20  * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY

    21  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES

    22  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;

    23  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND

    24  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

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

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

    27  */

    28 

    29 #if ENABLE(NETSCAPE_PLUGIN_API)

    30 

    31 #import "WebNetscapePluginView.h"

    32 

    33 #import "WebDataSourceInternal.h"

    34 #import "WebDefaultUIDelegate.h"

    35 #import "WebFrameInternal.h" 

    36 #import "WebFrameView.h"

    37 #import "WebKitErrorsPrivate.h"

    38 #import "WebKitLogging.h"

    39 #import "WebKitNSStringExtras.h"

    40 #import "WebKitSystemInterface.h"

    41 #import "WebNSDataExtras.h"

    42 #import "WebNSDictionaryExtras.h"

    43 #import "WebNSObjectExtras.h"

    44 #import "WebNSURLExtras.h"

    45 #import "WebNSURLRequestExtras.h"

    46 #import "WebNSViewExtras.h"

    47 #import "WebNetscapeContainerCheckContextInfo.h"

    48 #import "WebNetscapeContainerCheckPrivate.h"

    49 #import "WebNetscapePluginEventHandler.h"

    50 #import "WebNetscapePluginPackage.h"

    51 #import "WebNetscapePluginStream.h"

    52 #import "WebPluginContainerCheck.h"

    53 #import "WebPluginRequest.h"

    54 #import "WebPreferences.h"

    55 #import "WebUIDelegatePrivate.h"

    56 #import "WebViewInternal.h"

    57 #import <Carbon/Carbon.h>

    58 #import <WebCore/CookieJar.h>

    59 #import <WebCore/DocumentLoader.h>

    60 #import <WebCore/Element.h>

    61 #import <WebCore/Frame.h> 

    62 #import <WebCore/FrameLoader.h> 

    63 #import <WebCore/FrameTree.h>

    64 #import <WebCore/FrameView.h>

    65 #import <WebCore/HTMLPlugInElement.h>

    66 #import <WebCore/Page.h> 

    67 #import <WebCore/PluginMainThreadScheduler.h>

    68 #import <WebCore/ScriptController.h>

    69 #import <WebCore/SecurityOrigin.h>

    70 #import <WebCore/SoftLinking.h> 

    71 #import <WebCore/WebCoreObjCExtras.h>

    72 #import <WebCore/WebCoreURLResponse.h>

    73 #import <WebCore/npruntime_impl.h>

    74 #import <WebKit/DOMPrivate.h>

    75 #import <WebKit/WebUIDelegate.h>

    76 #import <objc/objc-runtime.h>

    77 #import <runtime/InitializeThreading.h>

    78 #import <runtime/JSLock.h>

    79 #import <wtf/Assertions.h>

    80 #import <wtf/Threading.h>

    81 #import <wtf/text/CString.h>

    82 

    83 #define LoginWindowDidSwitchFromUserNotification    @"WebLoginWindowDidSwitchFromUserNotification"

    84 #define LoginWindowDidSwitchToUserNotification      @"WebLoginWindowDidSwitchToUserNotification"

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

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

    87 

    88 using namespace WebCore;

    89 using namespace WebKit;

    90 using namespace std;

    91 

    92 static inline bool isDrawingModelQuickDraw(NPDrawingModel drawingModel)

    93 {

    94 #ifndef NP_NO_QUICKDRAW

    95     return drawingModel == NPDrawingModelQuickDraw;

    96 #else

    97     return false;

    98 #endif

    99 };

   100 

   101 @interface WebNetscapePluginView (Internal)

   102 - (NPError)_createPlugin;

   103 - (void)_destroyPlugin;

   104 - (NSBitmapImageRep *)_printedPluginBitmap;

   105 - (void)_redeliverStream;

   106 - (BOOL)_shouldCancelSrcStream;

   107 @end

   108 

   109 static WebNetscapePluginView *currentPluginView = nil;

   110 

   111 typedef struct OpaquePortState* PortState;

   112 

   113 static const double ThrottledTimerInterval = 0.25;

   114 

   115 class PluginTimer : public TimerBase {

   116 public:

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

   118     

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

   120         : m_npp(npp)

   121         , m_timerID(timerID)

   122         , m_interval(interval)

   123         , m_repeat(repeat)

   124         , m_timerFunc(timerFunc)

   125     {

   126     }

   127     

   128     void start(bool throttle)

   129     {

   130         ASSERT(!isActive());

   131 

   132         double timeInterval = m_interval / 1000.0;

   133         

   134         if (throttle)

   135             timeInterval = max(timeInterval, ThrottledTimerInterval);

   136         

   137         if (m_repeat)

   138             startRepeating(timeInterval);

   139         else

   140             startOneShot(timeInterval);

   141     }

   142 

   143 private:

   144     virtual void fired() 

   145     {

   146         m_timerFunc(m_npp, m_timerID);

   147         if (!m_repeat)

   148             delete this;

   149     }

   150     

   151     NPP m_npp;

   152     uint32_t m_timerID;

   153     uint32_t m_interval;

   154     NPBool m_repeat;

   155     TimerFunc m_timerFunc;

   156 };

   157 

   158 #ifndef NP_NO_QUICKDRAW

   159 

   160 // QuickDraw is not available in 64-bit

   161 

   162 typedef struct {

   163     GrafPtr oldPort;

   164     GDHandle oldDevice;

   165     Point oldOrigin;

   166     RgnHandle oldClipRegion;

   167     RgnHandle oldVisibleRegion;

   168     RgnHandle clipRegion;

   169     BOOL forUpdate;

   170 } PortState_QD;

   171 

   172 #endif /* NP_NO_QUICKDRAW */

   173 

   174 typedef struct {

   175     CGContextRef context;

   176 } PortState_CG;

   177 

   178 @class NSTextInputContext;

   179 @interface NSResponder (AppKitDetails)

   180 - (NSTextInputContext *)inputContext;

   181 @end

   182 

   183 @interface WebNetscapePluginView (ForwardDeclarations)

   184 - (void)setWindowIfNecessary;

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

   186 @end

   187 

   188 @implementation WebNetscapePluginView

   189 

   190 + (void)initialize

   191 {

   192     JSC::initializeThreading();

   193     WTF::initializeMainThreadToProcessMainThread();

   194 #ifndef BUILDING_ON_TIGER

   195     WebCoreObjCFinalizeOnMainThread(self);

   196 #endif

   197     WKSendUserChangeNotifications();

   198 }

   199 

   200 #pragma mark EVENTS

   201 

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

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

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

   205 - (void)fixWindowPort

   206 {

   207 #ifndef NP_NO_QUICKDRAW

   208     ASSERT(isDrawingModelQuickDraw(drawingModel));

   209     

   210     NSWindow *currentWindow = [self currentWindow];

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

   212         return;

   213     

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

   215     NSView *contentView = [currentWindow contentView];

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

   217     

   218     CGrafPtr oldPort;

   219     GetPort(&oldPort);    

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

   221     

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

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

   224     

   225     SetPort(oldPort);

   226 #endif

   227 }

   228 

   229 #ifndef NP_NO_QUICKDRAW

   230 static UInt32 getQDPixelFormatForBitmapContext(CGContextRef context)

   231 {

   232     UInt32 byteOrder = CGBitmapContextGetBitmapInfo(context) & kCGBitmapByteOrderMask;

   233     if (byteOrder == kCGBitmapByteOrderDefault)

   234         switch (CGBitmapContextGetBitsPerPixel(context)) {

   235             case 16:

   236                 byteOrder = kCGBitmapByteOrder16Host;

   237                 break;

   238             case 32:

   239                 byteOrder = kCGBitmapByteOrder32Host;

   240                 break;

   241         }

   242     switch (byteOrder) {

   243         case kCGBitmapByteOrder16Little:

   244             return k16LE555PixelFormat;

   245         case kCGBitmapByteOrder32Little:

   246             return k32BGRAPixelFormat;

   247         case kCGBitmapByteOrder16Big:

   248             return k16BE555PixelFormat;

   249         case kCGBitmapByteOrder32Big:

   250             return k32ARGBPixelFormat;

   251     }

   252     ASSERT_NOT_REACHED();

   253     return 0;

   254 }

   255 

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

   257 {

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

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

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

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

   262 }

   263 

   264 #endif

   265 

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

   267 {

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

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

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

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

   272 }

   273 

   274 - (PortState)saveAndSetNewPortStateForUpdate:(BOOL)forUpdate

   275 {

   276     ASSERT([self currentWindow] != nil);

   277     

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

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

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

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

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

   283     

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

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

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

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

   288     

   289 #ifndef NP_NO_QUICKDRAW

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

   291     ASSERT(windowRef);

   292 

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

   294     if (isDrawingModelQuickDraw(drawingModel)) {

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

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

   297         [self fixWindowPort];

   298         

   299         ::Rect portBounds;

   300         CGrafPtr port = GetWindowPort(windowRef);

   301         GetPortBounds(port, &portBounds);

   302 

   303         PixMap *pix = *GetPortPixMap(port);

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

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

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

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

   308     }

   309 #endif

   310     

   311     window.type = NPWindowTypeWindow;

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

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

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

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

   316     

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

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

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

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

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

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

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

   324 

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

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

   327         // WebCore will eventually resize us to.

   328 

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

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

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

   332 

   333         if (window.width <= 0)

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

   335         if (window.height <= 0)

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

   337 

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

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

   340         

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

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

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

   344         // compatible with this behavior.

   345         if (drawingModel == NPDrawingModelCoreAnimation)

   346             getNPRect(NSZeroRect, window.clipRect);

   347     } else {

   348         getNPRect(visibleRectInWindow, window.clipRect);

   349     }

   350     

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

   352     PortState portState;

   353     switch (drawingModel) {

   354 #ifndef NP_NO_QUICKDRAW

   355         case NPDrawingModelQuickDraw: {

   356             // Set up NS_Port.

   357             ::Rect portBounds;

   358             CGrafPtr port = GetWindowPort(windowRef);

   359             GetPortBounds(port, &portBounds);

   360             nPort.qdPort.port = port;

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

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

   363             window.window = &nPort;

   364 

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

   366             portState = (PortState)qdPortState;

   367             

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

   369 

   370             qdPortState->oldOrigin.h = portBounds.left;

   371             qdPortState->oldOrigin.v = portBounds.top;

   372 

   373             qdPortState->oldClipRegion = NewRgn();

   374             GetPortClipRegion(port, qdPortState->oldClipRegion);

   375             

   376             qdPortState->oldVisibleRegion = NewRgn();

   377             GetPortVisibleRegion(port, qdPortState->oldVisibleRegion);

   378             

   379             RgnHandle clipRegion = NewRgn();

   380             qdPortState->clipRegion = clipRegion;

   381 

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

   383             if (currentContext && WKCGContextIsBitmapContext(currentContext)) {

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

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

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

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

   388                 void* offscreenData = CGBitmapContextGetData(currentContext);

   389                 if (offscreenData) {

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

   391                     ::Rect offscreenBounds;

   392                     offscreenBounds.top = 0;

   393                     offscreenBounds.left = 0;

   394                     offscreenBounds.right = CGBitmapContextGetWidth(currentContext);

   395                     offscreenBounds.bottom = CGBitmapContextGetHeight(currentContext);

   396                     GWorldPtr newOffscreenGWorld;

   397                     QDErr err = NewGWorldFromPtr(&newOffscreenGWorld,

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

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

   400                     ASSERT(newOffscreenGWorld);

   401                     ASSERT(!err);

   402                     if (!err) {

   403                         if (offscreenGWorld)

   404                             DisposeGWorld(offscreenGWorld);

   405                         offscreenGWorld = newOffscreenGWorld;

   406 

   407                         SetGWorld(offscreenGWorld, NULL);

   408 

   409                         port = offscreenGWorld;

   410 

   411                         nPort.qdPort.port = port;

   412                         boundsInWindow = [self bounds];

   413                         

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

   415                         CGAffineTransform offscreenMatrix = CGContextGetCTM(currentContext);

   416                         CGPoint origin = {0,0};

   417                         CGPoint axisFlip = {1,1};

   418                         origin = CGPointApplyAffineTransform(origin, offscreenMatrix);

   419                         axisFlip = CGPointApplyAffineTransform(axisFlip, offscreenMatrix);

   420                         

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

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

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

   424                         

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

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

   427                         window.x = 0;

   428                         window.y = 0;

   429                         window.window = &nPort;

   430 

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

   432                         // from the window above.

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

   434                     }

   435                 }

   436             }

   437 

   438             MacSetRectRgn(clipRegion,

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

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

   441             

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

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

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

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

   446                 if (forUpdate) {

   447                     RgnHandle viewClipRegion = NewRgn();

   448                     

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

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

   451                     // knows about the true set of dirty rects.

   452                     NSView *opaqueAncestor = [self opaqueAncestor];

   453                     const NSRect *dirtyRects;

   454                     NSInteger dirtyRectCount, dirtyRectIndex;

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

   456 

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

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

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

   460                             // Create a region for this dirty rect

   461                             RgnHandle dirtyRectRegion = NewRgn();

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

   463                             

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

   465                             UnionRgn(viewClipRegion, dirtyRectRegion, viewClipRegion);

   466                             DisposeRgn(dirtyRectRegion);

   467                         }

   468                     }

   469                 

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

   471                     SectRgn(clipRegion, viewClipRegion, clipRegion);

   472                     DisposeRgn(viewClipRegion);

   473                 }

   474             }

   475 

   476             // Switch to the port and set it up.

   477             SetPort(port);

   478             PenNormal();

   479             ForeColor(blackColor);

   480             BackColor(whiteColor);

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

   482             SetPortClipRegion(nPort.qdPort.port, clipRegion);

   483 

   484             if (forUpdate) {

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

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

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

   488                 SetPortVisibleRegion(nPort.qdPort.port, clipRegion);

   489                 InvalWindowRgn(windowRef, clipRegion);

   490             }

   491             

   492             qdPortState->forUpdate = forUpdate;

   493             break;

   494         }

   495 #endif /* NP_NO_QUICKDRAW */

   496 

   497         case NPDrawingModelCoreGraphics: {            

   498             if (![self canDraw]) {

   499                 portState = NULL;

   500                 break;

   501             }

   502             

   503             ASSERT([NSView focusView] == self);

   504 

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

   506 

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

   508             portState = (PortState)cgPortState;

   509             cgPortState->context = context;

   510             

   511 #ifndef NP_NO_CARBON            

   512             if (eventModel != NPEventModelCocoa) {

   513                 // Update the plugin's window/context

   514                 nPort.cgPort.window = windowRef;

   515                 nPort.cgPort.context = context;

   516                 window.window = &nPort.cgPort;

   517             }                

   518 #endif /* NP_NO_CARBON */

   519 

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

   521             CGContextSaveGState(context);

   522 

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

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

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

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

   527                 // knows about the true set of dirty rects.

   528                 NSView *opaqueAncestor = [self opaqueAncestor];

   529                 const NSRect *dirtyRects;

   530                 NSInteger count;

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

   532                 Vector<CGRect, 16> convertedDirtyRects;

   533                 convertedDirtyRects.resize(count);

   534                 for (int i = 0; i < count; ++i)

   535                     reinterpret_cast<NSRect&>(convertedDirtyRects[i]) = [self convertRect:dirtyRects[i] fromView:opaqueAncestor];

   536                 CGContextClipToRects(context, convertedDirtyRects.data(), count);

   537             }

   538 

   539             break;

   540         }

   541           

   542         case NPDrawingModelCoreAnimation:

   543             // Just set the port state to a dummy value.

   544             portState = (PortState)1;

   545             break;

   546         

   547         default:

   548             ASSERT_NOT_REACHED();

   549             portState = NULL;

   550             break;

   551     }

   552     

   553     return portState;

   554 }

   555 

   556 - (PortState)saveAndSetNewPortState

   557 {

   558     return [self saveAndSetNewPortStateForUpdate:NO];

   559 }

   560 

   561 - (void)restorePortState:(PortState)portState

   562 {

   563     ASSERT([self currentWindow]);

   564     ASSERT(portState);

   565     

   566     switch (drawingModel) {

   567 #ifndef NP_NO_QUICKDRAW

   568         case NPDrawingModelQuickDraw: {

   569             PortState_QD *qdPortState = (PortState_QD *)portState;

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

   571             CGrafPtr port = GetWindowPort(windowRef);

   572 

   573             SetPort(port);

   574 

   575             if (qdPortState->forUpdate)

   576                 ValidWindowRgn(windowRef, qdPortState->clipRegion);

   577 

   578             SetOrigin(qdPortState->oldOrigin.h, qdPortState->oldOrigin.v);

   579 

   580             SetPortClipRegion(port, qdPortState->oldClipRegion);

   581             if (qdPortState->forUpdate)

   582                 SetPortVisibleRegion(port, qdPortState->oldVisibleRegion);

   583 

   584             DisposeRgn(qdPortState->oldClipRegion);

   585             DisposeRgn(qdPortState->oldVisibleRegion);

   586             DisposeRgn(qdPortState->clipRegion);

   587 

   588             SetGWorld(qdPortState->oldPort, qdPortState->oldDevice);

   589             break;

   590         }

   591 #endif /* NP_NO_QUICKDRAW */

   592         

   593         case NPDrawingModelCoreGraphics: {

   594             ASSERT([NSView focusView] == self);

   595             

   596             CGContextRef context = ((PortState_CG *)portState)->context;

   597             ASSERT(!nPort.cgPort.context || (context == nPort.cgPort.context));

   598             CGContextRestoreGState(context);

   599             break;

   600         }

   601         

   602         case NPDrawingModelCoreAnimation:

   603             ASSERT(portState == (PortState)1);

   604             break;

   605         default:

   606             ASSERT_NOT_REACHED();

   607             break;

   608     }

   609 }

   610 

   611 - (BOOL)sendEvent:(void*)event isDrawRect:(BOOL)eventIsDrawRect

   612 {

   613     if (![self window])

   614         return NO;

   615     ASSERT(event);

   616        

   617     if (!_isStarted)

   618         return NO;

   619 

   620     ASSERT([_pluginPackage.get() pluginFuncs]->event);

   621     

   622     // Make sure we don't call NPP_HandleEvent while we're inside NPP_SetWindow.

   623     // We probably don't want more general reentrancy protection; we are really

   624     // protecting only against this one case, which actually comes up when

   625     // you first install the SVG viewer plug-in.

   626     if (inSetWindow)

   627         return NO;

   628 

   629     Frame* frame = core([self webFrame]);

   630     if (!frame)

   631         return NO;

   632     Page* page = frame->page();

   633     if (!page)

   634         return NO;

   635 

   636     // Can only send drawRect (updateEvt) to CoreGraphics plugins when actually drawing

   637     ASSERT((drawingModel != NPDrawingModelCoreGraphics) || !eventIsDrawRect || [NSView focusView] == self);

   638     

   639     PortState portState = NULL;

   640     

   641     if (isDrawingModelQuickDraw(drawingModel) || (drawingModel != NPDrawingModelCoreAnimation && eventIsDrawRect)) {

   642         // In CoreGraphics mode, the port state only needs to be saved/set when redrawing the plug-in view.

   643         // The plug-in is not allowed to draw at any other time.

   644         portState = [self saveAndSetNewPortStateForUpdate:eventIsDrawRect];

   645         // We may have changed the window, so inform the plug-in.

   646         [self setWindowIfNecessary];

   647     }

   648     

   649 #if !defined(NDEBUG) && !defined(NP_NO_QUICKDRAW)

   650     // Draw green to help debug.

   651     // If we see any green we know something's wrong.

   652     // Note that PaintRect() only works for QuickDraw plugins; otherwise the current QD port is undefined.

   653     if (isDrawingModelQuickDraw(drawingModel) && eventIsDrawRect) {

   654         ForeColor(greenColor);

   655         const ::Rect bigRect = { -10000, -10000, 10000, 10000 };

   656         PaintRect(&bigRect);

   657         ForeColor(blackColor);

   658     }

   659 #endif

   660     

   661     // Temporarily retain self in case the plug-in view is released while sending an event. 

   662     [[self retain] autorelease];

   663     

   664     BOOL acceptedEvent;

   665     [self willCallPlugInFunction];

   666     {

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

   668         acceptedEvent = [_pluginPackage.get() pluginFuncs]->event(plugin, event);

   669     }

   670     [self didCallPlugInFunction];

   671         

   672     if (portState) {

   673         if ([self currentWindow])

   674             [self restorePortState:portState];

   675         if (portState != (PortState)1)

   676             free(portState);

   677     }

   678 

   679     return acceptedEvent;

   680 }

   681 

   682 - (void)windowFocusChanged:(BOOL)hasFocus

   683 {

   684     _eventHandler->windowFocusChanged(hasFocus);

   685 }

   686 

   687 - (void)sendDrawRectEvent:(NSRect)rect

   688 {

   689     ASSERT(_eventHandler);

   690     

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

   692     _eventHandler->drawRect(context, rect);

   693 }

   694 

   695 - (void)stopTimers

   696 {

   697     [super stopTimers];

   698     

   699     if (_eventHandler)

   700         _eventHandler->stopTimers();

   701     

   702     if (!timers)

   703         return;

   704 

   705     HashMap<uint32_t, PluginTimer*>::const_iterator end = timers->end();

   706     for (HashMap<uint32_t, PluginTimer*>::const_iterator it = timers->begin(); it != end; ++it) {

   707         PluginTimer* timer = it->second;

   708         timer->stop();

   709     }    

   710 }

   711 

   712 - (void)startTimers

   713 {

   714     [super startTimers];

   715     

   716     // If the plugin is completely obscured (scrolled out of view, for example), then we will

   717     // send null events at a reduced rate.

   718     _eventHandler->startTimers(_isCompletelyObscured);

   719     

   720     if (!timers)

   721         return;

   722     

   723     HashMap<uint32_t, PluginTimer*>::const_iterator end = timers->end();

   724     for (HashMap<uint32_t, PluginTimer*>::const_iterator it = timers->begin(); it != end; ++it) {

   725         PluginTimer* timer = it->second;

   726         ASSERT(!timer->isActive());

   727         timer->start(_isCompletelyObscured);

   728     }    

   729 }

   730 

   731 - (void)focusChanged

   732 {

   733     // We need to null check the event handler here because

   734     // the plug-in view can resign focus after it's been stopped

   735     // and the event handler has been deleted.

   736     if (_eventHandler)

   737         _eventHandler->focusChanged(_hasFocus);

   738 }

   739 

   740 - (void)mouseDown:(NSEvent *)theEvent

   741 {

   742     if (!_isStarted)

   743         return;

   744 

   745     _eventHandler->mouseDown(theEvent);

   746 }

   747 

   748 - (void)mouseUp:(NSEvent *)theEvent

   749 {

   750     if (!_isStarted)

   751         return;

   752 

   753     _eventHandler->mouseUp(theEvent);

   754 }

   755 

   756 - (void)handleMouseEntered:(NSEvent *)theEvent

   757 {

   758     if (!_isStarted)

   759         return;

   760 

   761     // Set cursor to arrow. Plugins often handle cursor internally, but those that don't will just get this default one.

   762     [[NSCursor arrowCursor] set];

   763 

   764     _eventHandler->mouseEntered(theEvent);

   765 }

   766 

   767 - (void)handleMouseExited:(NSEvent *)theEvent

   768 {

   769     if (!_isStarted)

   770         return;

   771 

   772     _eventHandler->mouseExited(theEvent);

   773     

   774     // Set cursor back to arrow cursor.  Because NSCursor doesn't know about changes that the plugin made, we could get confused about what we think the

   775     // current cursor is otherwise.  Therefore we have no choice but to unconditionally reset the cursor when the mouse exits the plugin.

   776     [[NSCursor arrowCursor] set];

   777 }

   778 

   779 - (void)handleMouseMoved:(NSEvent *)theEvent

   780 {

   781     if (!_isStarted)

   782         return;

   783 

   784     _eventHandler->mouseMoved(theEvent);

   785 }

   786     

   787 - (void)mouseDragged:(NSEvent *)theEvent

   788 {

   789     if (!_isStarted)

   790         return;

   791 

   792     _eventHandler->mouseDragged(theEvent);

   793 }

   794 

   795 - (void)scrollWheel:(NSEvent *)theEvent

   796 {

   797     if (!_isStarted) {

   798         [super scrollWheel:theEvent];

   799         return;

   800     }

   801 

   802     if (!_eventHandler->scrollWheel(theEvent))

   803         [super scrollWheel:theEvent];

   804 }

   805 

   806 - (void)keyUp:(NSEvent *)theEvent

   807 {

   808     if (!_isStarted)

   809         return;

   810 

   811     _eventHandler->keyUp(theEvent);

   812 }

   813 

   814 - (void)keyDown:(NSEvent *)theEvent

   815 {

   816     if (!_isStarted)

   817         return;

   818 

   819     _eventHandler->keyDown(theEvent);

   820 }

   821 

   822 - (void)flagsChanged:(NSEvent *)theEvent

   823 {

   824     if (!_isStarted)

   825         return;

   826 

   827     _eventHandler->flagsChanged(theEvent);

   828 }

   829 

   830 - (void)sendModifierEventWithKeyCode:(int)keyCode character:(char)character

   831 {

   832     if (!_isStarted)

   833         return;

   834     

   835     _eventHandler->syntheticKeyDownWithCommandModifier(keyCode, character);

   836 }

   837 

   838 - (void)privateBrowsingModeDidChange

   839 {

   840     if (!_isStarted)

   841         return;

   842     

   843     NPBool value = _isPrivateBrowsingEnabled;

   844 

   845     [self willCallPlugInFunction];

   846     {

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

   848         if ([_pluginPackage.get() pluginFuncs]->setvalue)

   849             [_pluginPackage.get() pluginFuncs]->setvalue(plugin, NPNVprivateModeBool, &value);

   850     }

   851     [self didCallPlugInFunction];

   852 }

   853 

   854 #pragma mark WEB_NETSCAPE_PLUGIN

   855 

   856 - (BOOL)isNewWindowEqualToOldWindow

   857 {

   858     if (window.x != lastSetWindow.x)

   859         return NO;

   860     if (window.y != lastSetWindow.y)

   861         return NO;

   862     if (window.width != lastSetWindow.width)

   863         return NO;

   864     if (window.height != lastSetWindow.height)

   865         return NO;

   866     if (window.clipRect.top != lastSetWindow.clipRect.top)

   867         return NO;

   868     if (window.clipRect.left != lastSetWindow.clipRect.left)

   869         return NO;

   870     if (window.clipRect.bottom  != lastSetWindow.clipRect.bottom)

   871         return NO;

   872     if (window.clipRect.right != lastSetWindow.clipRect.right)

   873         return NO;

   874     if (window.type != lastSetWindow.type)

   875         return NO;

   876     

   877     switch (drawingModel) {

   878 #ifndef NP_NO_QUICKDRAW

   879         case NPDrawingModelQuickDraw:

   880             if (nPort.qdPort.portx != lastSetPort.qdPort.portx)

   881                 return NO;

   882             if (nPort.qdPort.porty != lastSetPort.qdPort.porty)

   883                 return NO;

   884             if (nPort.qdPort.port != lastSetPort.qdPort.port)

   885                 return NO;

   886         break;

   887 #endif /* NP_NO_QUICKDRAW */

   888             

   889         case NPDrawingModelCoreGraphics:

   890             if (nPort.cgPort.window != lastSetPort.cgPort.window)

   891                 return NO;

   892             if (nPort.cgPort.context != lastSetPort.cgPort.context)

   893                 return NO;

   894         break;

   895                     

   896         case NPDrawingModelCoreAnimation:

   897           if (window.window != lastSetWindow.window)

   898               return NO;

   899           break;

   900         default:

   901             ASSERT_NOT_REACHED();

   902         break;

   903     }

   904     

   905     return YES;

   906 }

   907 

   908 -(void)tellQuickTimeToChill

   909 {

   910 #ifndef NP_NO_QUICKDRAW

   911     ASSERT(isDrawingModelQuickDraw(drawingModel));

   912     

   913     // Make a call to the secret QuickDraw API that makes QuickTime calm down.

   914     WindowRef windowRef = (WindowRef)[[self window] windowRef];

   915     if (!windowRef) {

   916         return;

   917     }

   918     CGrafPtr port = GetWindowPort(windowRef);

   919     ::Rect bounds;

   920     GetPortBounds(port, &bounds);

   921     WKCallDrawingNotification(port, &bounds);

   922 #endif /* NP_NO_QUICKDRAW */

   923 }

   924 

   925 - (void)updateAndSetWindow

   926 {

   927     // A plug-in can only update if it's (1) already been started (2) isn't stopped

   928     // and (3) is able to draw on-screen. To meet condition (3) the plug-in must not

   929     // be hidden and be attached to a window. There are two exceptions to this rule:

   930     //

   931     // Exception 1: QuickDraw plug-ins must be manually told when to stop writing

   932     // bits to the window backing store, thus to do so requires a new call to

   933     // NPP_SetWindow() with an empty NPWindow struct.

   934     //

   935     // Exception 2: CoreGraphics plug-ins expect to have their drawable area updated

   936     // when they are moved to a background tab, via a NPP_SetWindow call. This is

   937     // accomplished by allowing -saveAndSetNewPortStateForUpdate to "clip-out" the window's

   938     // clipRect. Flash is curently an exception to this. See 6453738.

   939     //

   940     

   941     if (!_isStarted)

   942         return;

   943     

   944 #ifdef NP_NO_QUICKDRAW

   945     if (![self canDraw])

   946         return;

   947 #else

   948     if (drawingModel == NPDrawingModelQuickDraw)

   949         [self tellQuickTimeToChill];

   950     else if (drawingModel == NPDrawingModelCoreGraphics && ![self canDraw] && _isFlash) {

   951         // The Flash plug-in does not expect an NPP_SetWindow call from WebKit in this case.

   952         // See Exception 2 above.

   953         return;

   954     }

   955 #endif // NP_NO_QUICKDRAW

   956     

   957     BOOL didLockFocus = [NSView focusView] != self && [self lockFocusIfCanDraw];

   958 

   959     PortState portState = [self saveAndSetNewPortState];

   960     if (portState) {

   961         [self setWindowIfNecessary];

   962         [self restorePortState:portState];

   963         if (portState != (PortState)1)

   964             free(portState);

   965     } else if (drawingModel == NPDrawingModelCoreGraphics)

   966         [self setWindowIfNecessary];        

   967 

   968     if (didLockFocus)

   969         [self unlockFocus];

   970 }

   971 

   972 - (void)setWindowIfNecessary

   973 {

   974     if (!_isStarted) 

   975         return;

   976     

   977     if (![self isNewWindowEqualToOldWindow]) {        

   978         // Make sure we don't call NPP_HandleEvent while we're inside NPP_SetWindow.

   979         // We probably don't want more general reentrancy protection; we are really

   980         // protecting only against this one case, which actually comes up when

   981         // you first install the SVG viewer plug-in.

   982         NPError npErr;

   983         ASSERT(!inSetWindow);

   984         

   985         inSetWindow = YES;        

   986         [self willCallPlugInFunction];

   987         {

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

   989             npErr = [_pluginPackage.get() pluginFuncs]->setwindow(plugin, &window);

   990         }

   991         [self didCallPlugInFunction];

   992         inSetWindow = NO;

   993 

   994 #ifndef NDEBUG

   995         switch (drawingModel) {

   996 #ifndef NP_NO_QUICKDRAW

   997             case NPDrawingModelQuickDraw:

   998                 LOG(Plugins, "NPP_SetWindow (QuickDraw): %d, port=0x%08x, window.x:%d window.y:%d window.width:%d window.height:%d",

   999                 npErr, (int)nPort.qdPort.port, (int)window.x, (int)window.y, (int)window.width, (int)window.height);

  1000             break;

  1001 #endif /* NP_NO_QUICKDRAW */

  1002             

  1003             case NPDrawingModelCoreGraphics:

  1004                 LOG(Plugins, "NPP_SetWindow (CoreGraphics): %d, window=%p, context=%p, window.x:%d window.y:%d window.width:%d window.height:%d window.clipRect size:%dx%d",

  1005                 npErr, nPort.cgPort.window, nPort.cgPort.context, (int)window.x, (int)window.y, (int)window.width, (int)window.height, 

  1006                     window.clipRect.right - window.clipRect.left, window.clipRect.bottom - window.clipRect.top);

  1007             break;

  1008 

  1009             case NPDrawingModelCoreAnimation:

  1010                 LOG(Plugins, "NPP_SetWindow (CoreAnimation): %d, window=%p window.x:%d window.y:%d window.width:%d window.height:%d",

  1011                 npErr, window.window, nPort.cgPort.context, (int)window.x, (int)window.y, (int)window.width, (int)window.height);

  1012             break;

  1013 

  1014             default:

  1015                 ASSERT_NOT_REACHED();

  1016             break;

  1017         }

  1018 #endif /* !defined(NDEBUG) */

  1019         

  1020         lastSetWindow = window;

  1021         lastSetPort = nPort;

  1022     }

  1023 }

  1024 

  1025 + (void)setCurrentPluginView:(WebNetscapePluginView *)view

  1026 {

  1027     currentPluginView = view;

  1028 }

  1029 

  1030 + (WebNetscapePluginView *)currentPluginView

  1031 {

  1032     return currentPluginView;

  1033 }

  1034 

  1035 - (BOOL)createPlugin

  1036 {

  1037     // Open the plug-in package so it remains loaded while our plugin uses it

  1038     [_pluginPackage.get() open];

  1039     

  1040     // Initialize drawingModel to an invalid value so that we can detect when the plugin does not specify a drawingModel

  1041     drawingModel = (NPDrawingModel)-1;

  1042     

  1043     // Initialize eventModel to an invalid value so that we can detect when the plugin does not specify an event model.

  1044     eventModel = (NPEventModel)-1;

  1045     

  1046     NPError npErr = [self _createPlugin];

  1047     if (npErr != NPERR_NO_ERROR) {

  1048         LOG_ERROR("NPP_New failed with error: %d", npErr);

  1049         [self _destroyPlugin];

  1050         [_pluginPackage.get() close];

  1051         return NO;

  1052     }

  1053     

  1054     if (drawingModel == (NPDrawingModel)-1) {

  1055 #ifndef NP_NO_QUICKDRAW

  1056         // Default to QuickDraw if the plugin did not specify a drawing model.

  1057         drawingModel = NPDrawingModelQuickDraw;

  1058 #else

  1059         // QuickDraw is not available, so we can't default to it. Instead, default to CoreGraphics.

  1060         drawingModel = NPDrawingModelCoreGraphics;

  1061 #endif

  1062     }

  1063 

  1064     if (eventModel == (NPEventModel)-1) {

  1065         // If the plug-in did not specify a drawing model we default to Carbon when it is available.

  1066 #ifndef NP_NO_CARBON

  1067         eventModel = NPEventModelCarbon;

  1068 #else

  1069         eventModel = NPEventModelCocoa;

  1070 #endif // NP_NO_CARBON

  1071     }

  1072 

  1073 #ifndef NP_NO_CARBON

  1074     if (eventModel == NPEventModelCocoa && isDrawingModelQuickDraw(drawingModel)) {

  1075         LOG(Plugins, "Plugin can't use use Cocoa event model with QuickDraw drawing model: %@", _pluginPackage.get());

  1076         [self _destroyPlugin];

  1077         [_pluginPackage.get() close];

  1078         

  1079         return NO;

  1080     }        

  1081 #endif // NP_NO_CARBON

  1082     

  1083 #ifndef BUILDING_ON_TIGER

  1084     if (drawingModel == NPDrawingModelCoreAnimation) {

  1085         void *value = 0;

  1086         if ([_pluginPackage.get() pluginFuncs]->getvalue(plugin, NPPVpluginCoreAnimationLayer, &value) == NPERR_NO_ERROR && value) {

  1087 

  1088             // The plug-in gives us a retained layer.

  1089             _pluginLayer.adoptNS((CALayer *)value);

  1090 

  1091             BOOL accleratedCompositingEnabled = false;

  1092 #if USE(ACCELERATED_COMPOSITING)

  1093             accleratedCompositingEnabled = [[[self webView] preferences] acceleratedCompositingEnabled];

  1094 #endif

  1095             if (accleratedCompositingEnabled) {

  1096                 // FIXME: This code can be shared between WebHostedNetscapePluginView and WebNetscapePluginView.

  1097 #ifndef BUILDING_ON_LEOPARD

  1098                 // Since this layer isn't going to be inserted into a view, we need to create another layer and flip its geometry

  1099                 // in order to get the coordinate system right.

  1100                 RetainPtr<CALayer> realPluginLayer(AdoptNS, _pluginLayer.releaseRef());

  1101                 

  1102                 _pluginLayer.adoptNS([[CALayer alloc] init]);

  1103                 _pluginLayer.get().bounds = realPluginLayer.get().bounds;

  1104                 _pluginLayer.get().geometryFlipped = YES;

  1105 

  1106                 realPluginLayer.get().autoresizingMask = kCALayerWidthSizable | kCALayerHeightSizable;

  1107                 [_pluginLayer.get() addSublayer:realPluginLayer.get()];

  1108 #endif

  1109                 // Eagerly enter compositing mode, since we know we'll need it. This avoids firing setNeedsStyleRecalc()

  1110                 // for iframes that contain composited plugins at bad times. https://bugs.webkit.org/show_bug.cgi?id=39033

  1111                 core([self webFrame])->view()->enterCompositingMode();

  1112                 [self element]->setNeedsStyleRecalc(SyntheticStyleChange);

  1113             } else

  1114                 [self setWantsLayer:YES];

  1115 

  1116             LOG(Plugins, "%@ is using Core Animation drawing model with layer %@", _pluginPackage.get(), _pluginLayer.get());

  1117         }

  1118 

  1119         ASSERT(_pluginLayer);

  1120     }

  1121 #endif

  1122     

  1123     // Create the event handler

  1124     _eventHandler.set(WebNetscapePluginEventHandler::create(self));

  1125         

  1126     return YES;

  1127 }

  1128 

  1129 #ifndef BUILDING_ON_TIGER

  1130 // FIXME: This method is an ideal candidate to move up to the base class

  1131 - (CALayer *)pluginLayer

  1132 {

  1133     return _pluginLayer.get();

  1134 }

  1135