The Tor Browser / file revision

 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */

 // vim:set ts=2 sts=2 sw=2 et cin:

 // Copyright (c) 2006-2008 The Chromium Authors. All rights reserved.

 //

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

 // modification, are permitted provided that the following conditions are

 // met:

 //

 //    * Redistributions of source code must retain the above copyright

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

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

 //    * Neither the name of Google Inc. 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 THE COPYRIGHT HOLDERS AND 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 THE COPYRIGHT

 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT

 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,

 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

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

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

 #include "base/basictypes.h"

 #include "nsCocoaUtils.h"

 #include "PluginModuleChild.h"

 #include "nsDebug.h"

 #include "PluginInterposeOSX.h"

 #include <set>

 #import <AppKit/AppKit.h>

 #import <objc/runtime.h>

 #import <Carbon/Carbon.h>

 using mozilla::plugins::PluginModuleChild;

 using mozilla::plugins::AssertPluginThread;

 namespace mac_plugin_interposing {

 int32_t NSCursorInfo::mNativeCursorsSupported = -1;

 // This constructor may be called from the browser process or the plugin

 // process.

 NSCursorInfo::NSCursorInfo()

   : mType(TypeArrow)

   , mHotSpot(nsPoint(0, 0))

   , mCustomImageData(NULL)

   , mCustomImageDataLength(0)

 {

 }

 NSCursorInfo::NSCursorInfo(NSCursor* aCursor)

   : mType(TypeArrow)

   , mHotSpot(nsPoint(0, 0))

   , mCustomImageData(NULL)

   , mCustomImageDataLength(0)

 {

   // This constructor is only ever called from the plugin process, so the

   // following is safe.

   if (!GetNativeCursorsSupported()) {

     return;

   }

   NSPoint hotSpotCocoa = [aCursor hotSpot];

   mHotSpot = nsPoint(hotSpotCocoa.x, hotSpotCocoa.y);

   Class nsCursorClass = [NSCursor class];

   if ([aCursor isEqual:[NSCursor arrowCursor]]) {

     mType = TypeArrow;

   } else if ([aCursor isEqual:[NSCursor closedHandCursor]]) {

     mType = TypeClosedHand;

   } else if ([aCursor isEqual:[NSCursor crosshairCursor]]) {

     mType = TypeCrosshair;

   } else if ([aCursor isEqual:[NSCursor disappearingItemCursor]]) {

     mType = TypeDisappearingItem;

   } else if ([aCursor isEqual:[NSCursor IBeamCursor]]) {

     mType = TypeIBeam;

   } else if ([aCursor isEqual:[NSCursor openHandCursor]]) {

     mType = TypeOpenHand;

   } else if ([aCursor isEqual:[NSCursor pointingHandCursor]]) {

     mType = TypePointingHand;

   } else if ([aCursor isEqual:[NSCursor resizeDownCursor]]) {

     mType = TypeResizeDown;

   } else if ([aCursor isEqual:[NSCursor resizeLeftCursor]]) {

     mType = TypeResizeLeft;

   } else if ([aCursor isEqual:[NSCursor resizeLeftRightCursor]]) {

     mType = TypeResizeLeftRight;

   } else if ([aCursor isEqual:[NSCursor resizeRightCursor]]) {

     mType = TypeResizeRight;

   } else if ([aCursor isEqual:[NSCursor resizeUpCursor]]) {

     mType = TypeResizeUp;

   } else if ([aCursor isEqual:[NSCursor resizeUpDownCursor]]) {

     mType = TypeResizeUpDown;

   // The following cursor types are only supported on OS X 10.6 and up.

   } else if ([nsCursorClass respondsToSelector:@selector(contextualMenuCursor)] &&

              [aCursor isEqual:[nsCursorClass performSelector:@selector(contextualMenuCursor)]]) {

     mType = TypeContextualMenu;

   } else if ([nsCursorClass respondsToSelector:@selector(dragCopyCursor)] &&

              [aCursor isEqual:[nsCursorClass performSelector:@selector(dragCopyCursor)]]) {

     mType = TypeDragCopy;

   } else if ([nsCursorClass respondsToSelector:@selector(dragLinkCursor)] &&

              [aCursor isEqual:[nsCursorClass performSelector:@selector(dragLinkCursor)]]) {

     mType = TypeDragLink;

   } else if ([nsCursorClass respondsToSelector:@selector(operationNotAllowedCursor)] &&

              [aCursor isEqual:[nsCursorClass performSelector:@selector(operationNotAllowedCursor)]]) {

     mType = TypeNotAllowed;

   } else {

     NSImage* image = [aCursor image];

     NSArray* reps = image ? [image representations] : nil;

     NSUInteger repsCount = reps ? [reps count] : 0;

     if (!repsCount) {

       // If we have a custom cursor with no image representations, assume we

       // need a transparent cursor.

       mType = TypeTransparent;

     } else {

       CGImageRef cgImage = nil;

       // XXX We don't know how to deal with a cursor that doesn't have a

       //     bitmap image representation.  For now we fall back to an arrow

       //     cursor.

       for (NSUInteger i = 0; i < repsCount; ++i) {

         id rep = [reps objectAtIndex:i];

         if ([rep isKindOfClass:[NSBitmapImageRep class]]) {

           cgImage = [(NSBitmapImageRep*)rep CGImage];

           break;

         }

       }

       if (cgImage) {

         CFMutableDataRef data = ::CFDataCreateMutable(kCFAllocatorDefault, 0);

         if (data) {

           CGImageDestinationRef dest = ::CGImageDestinationCreateWithData(data,

                                                                           kUTTypePNG,

                                                                           1,

                                                                           NULL);

           if (dest) {

             ::CGImageDestinationAddImage(dest, cgImage, NULL);

             if (::CGImageDestinationFinalize(dest)) {

               uint32_t dataLength = (uint32_t) ::CFDataGetLength(data);

               mCustomImageData = (uint8_t*) moz_xmalloc(dataLength);

               ::CFDataGetBytes(data, ::CFRangeMake(0, dataLength), mCustomImageData);

               mCustomImageDataLength = dataLength;

               mType = TypeCustom;

             }

             ::CFRelease(dest);

           }

           ::CFRelease(data);

         }

       }

       if (!mCustomImageData) {

         mType = TypeArrow;

       }

     }

   }

 }

 NSCursorInfo::NSCursorInfo(const Cursor* aCursor)

   : mType(TypeArrow)

   , mHotSpot(nsPoint(0, 0))

   , mCustomImageData(NULL)

   , mCustomImageDataLength(0)

 {

   // This constructor is only ever called from the plugin process, so the

   // following is safe.

   if (!GetNativeCursorsSupported()) {

     return;

   }

   mHotSpot = nsPoint(aCursor->hotSpot.h, aCursor->hotSpot.v);

   int width = 16, height = 16;

   int bytesPerPixel = 4;

   int rowBytes = width * bytesPerPixel;

   int bitmapSize = height * rowBytes;

   bool isTransparent = true;

   uint8_t* bitmap = (uint8_t*) moz_xmalloc(bitmapSize);

   // The way we create 'bitmap' is largely "borrowed" from Chrome's

   // WebCursor::InitFromCursor().

   for (int y = 0; y < height; ++y) {

     unsigned short data = aCursor->data[y];

     unsigned short mask = aCursor->mask[y];

     // Change 'data' and 'mask' from big-endian to little-endian, but output

     // big-endian data below.

     data = ((data << 8) & 0xFF00) | ((data >> 8) & 0x00FF);

     mask = ((mask << 8) & 0xFF00) | ((mask >> 8) & 0x00FF);

     // It'd be nice to use a gray-scale bitmap.  But

     // CGBitmapContextCreateImage() (used below) won't work with one that also

     // has alpha values.

     for (int x = 0; x < width; ++x) {

       int offset = (y * rowBytes) + (x * bytesPerPixel);

       // Color value

       if (data & 0x8000) {

         bitmap[offset]     = 0x0;

         bitmap[offset + 1] = 0x0;

         bitmap[offset + 2] = 0x0;

       } else {

         bitmap[offset]     = 0xFF;

         bitmap[offset + 1] = 0xFF;

         bitmap[offset + 2] = 0xFF;

       }

       // Mask value

       if (mask & 0x8000) {

         bitmap[offset + 3] = 0xFF;

         isTransparent = false;

       } else {

         bitmap[offset + 3] = 0x0;

       }

       data <<= 1;

       mask <<= 1;

     }

   }

   if (isTransparent) {

     // If aCursor is transparent, we don't need to serialize custom cursor

     // data over IPC.

     mType = TypeTransparent;

   } else {

     CGColorSpaceRef color = ::CGColorSpaceCreateDeviceRGB();

     if (color) {

       CGContextRef context =

         ::CGBitmapContextCreate(bitmap,

                                 width,

                                 height,

                                 8,

                                 rowBytes,

                                 color,

                                 kCGImageAlphaPremultipliedLast |

                                   kCGBitmapByteOrder32Big);

       if (context) {

         CGImageRef image = ::CGBitmapContextCreateImage(context);

         if (image) {

           ::CFMutableDataRef data = ::CFDataCreateMutable(kCFAllocatorDefault, 0);

           if (data) {

             CGImageDestinationRef dest =

               ::CGImageDestinationCreateWithData(data,

                                                  kUTTypePNG,

                                                  1,

                                                  NULL);

             if (dest) {

               ::CGImageDestinationAddImage(dest, image, NULL);

               if (::CGImageDestinationFinalize(dest)) {

                 uint32_t dataLength = (uint32_t) ::CFDataGetLength(data);

                 mCustomImageData = (uint8_t*) moz_xmalloc(dataLength);

                 ::CFDataGetBytes(data,

                                  ::CFRangeMake(0, dataLength),

                                  mCustomImageData);

                 mCustomImageDataLength = dataLength;

                 mType = TypeCustom;

               }

               ::CFRelease(dest);

             }

             ::CFRelease(data);

           }

           ::CGImageRelease(image);

         }

         ::CGContextRelease(context);

       }

       ::CGColorSpaceRelease(color);

     }

   }

   moz_free(bitmap);

 }

 NSCursorInfo::~NSCursorInfo()

 {

   if (mCustomImageData) {

     moz_free(mCustomImageData);

   }

 }

 NSCursor* NSCursorInfo::GetNSCursor() const

 {

   NSCursor* retval = nil;

   Class nsCursorClass = [NSCursor class];

   switch(mType) {

     case TypeArrow:

       retval = [NSCursor arrowCursor];

       break;

     case TypeClosedHand:

       retval = [NSCursor closedHandCursor];

       break;

     case TypeCrosshair:

       retval = [NSCursor crosshairCursor];

       break;

     case TypeDisappearingItem:

       retval = [NSCursor disappearingItemCursor];

       break;

     case TypeIBeam:

       retval = [NSCursor IBeamCursor];

       break;

     case TypeOpenHand:

       retval = [NSCursor openHandCursor];

       break;

     case TypePointingHand:

       retval = [NSCursor pointingHandCursor];

       break;

     case TypeResizeDown:

       retval = [NSCursor resizeDownCursor];

       break;

     case TypeResizeLeft:

       retval = [NSCursor resizeLeftCursor];

       break;

     case TypeResizeLeftRight:

       retval = [NSCursor resizeLeftRightCursor];

       break;

     case TypeResizeRight:

       retval = [NSCursor resizeRightCursor];

       break;

     case TypeResizeUp:

       retval = [NSCursor resizeUpCursor];

       break;

     case TypeResizeUpDown:

       retval = [NSCursor resizeUpDownCursor];

       break;

     // The following four cursor types are only supported on OS X 10.6 and up.

     case TypeContextualMenu: {

       if ([nsCursorClass respondsToSelector:@selector(contextualMenuCursor)]) {

         retval = [nsCursorClass performSelector:@selector(contextualMenuCursor)];

       }

       break;

     }

     case TypeDragCopy: {

       if ([nsCursorClass respondsToSelector:@selector(dragCopyCursor)]) {

         retval = [nsCursorClass performSelector:@selector(dragCopyCursor)];

       }

       break;

     }

     case TypeDragLink: {

       if ([nsCursorClass respondsToSelector:@selector(dragLinkCursor)]) {

         retval = [nsCursorClass performSelector:@selector(dragLinkCursor)];

       }

       break;

     }

     case TypeNotAllowed: {

       if ([nsCursorClass respondsToSelector:@selector(operationNotAllowedCursor)]) {

         retval = [nsCursorClass performSelector:@selector(operationNotAllowedCursor)];

       }

       break;

     }

     case TypeTransparent:

       retval = GetTransparentCursor();

       break;

     default:

       break;

   }

   if (!retval && mCustomImageData && mCustomImageDataLength) {

     CGDataProviderRef provider = ::CGDataProviderCreateWithData(NULL,

                                                                 (const void*)mCustomImageData,

                                                                 mCustomImageDataLength,

                                                                 NULL);

     if (provider) {

       CGImageRef cgImage = ::CGImageCreateWithPNGDataProvider(provider,

                                                               NULL,

                                                               false,

                                                               kCGRenderingIntentDefault);

       if (cgImage) {

         NSBitmapImageRep* rep = [[NSBitmapImageRep alloc] initWithCGImage:cgImage];

         if (rep) {

           NSImage* image = [[NSImage alloc] init];

           if (image) {

             [image addRepresentation:rep];

             retval = [[[NSCursor alloc] initWithImage:image 

                                               hotSpot:NSMakePoint(mHotSpot.x, mHotSpot.y)]

                       autorelease];

             [image release];

           }

           [rep release];

         }

         ::CGImageRelease(cgImage);

       }

       ::CFRelease(provider);

     }

   }

   // Fall back to an arrow cursor if need be.

   if (!retval) {

     retval = [NSCursor arrowCursor];

   }

   return retval;

 }

 // Get a transparent cursor with the appropriate hot spot.  We need one if

 // (for example) we have a custom cursor with no image data.

 NSCursor* NSCursorInfo::GetTransparentCursor() const

 {

   NSCursor* retval = nil;

   int width = 16, height = 16;

   int bytesPerPixel = 2;

   int rowBytes = width * bytesPerPixel;

   int dataSize = height * rowBytes;

   uint8_t* data = (uint8_t*) moz_xmalloc(dataSize);

   for (int y = 0; y < height; ++y) {

     for (int x = 0; x < width; ++x) {

       int offset = (y * rowBytes) + (x * bytesPerPixel);

       data[offset] = 0x7E;  // Arbitrary gray-scale value

       data[offset + 1] = 0; // Alpha value to make us transparent

     }

   }

   NSBitmapImageRep* imageRep =

     [[[NSBitmapImageRep alloc] initWithBitmapDataPlanes:nil

                                              pixelsWide:width

                                              pixelsHigh:height

                                           bitsPerSample:8

                                         samplesPerPixel:2

                                                hasAlpha:YES

                                                isPlanar:NO

                                          colorSpaceName:NSCalibratedWhiteColorSpace

                                             bytesPerRow:rowBytes

                                            bitsPerPixel:16]

      autorelease];

   if (imageRep) {

     uint8_t* repDataPtr = [imageRep bitmapData];

     if (repDataPtr) {

       memcpy(repDataPtr, data, dataSize);

       NSImage *image =

         [[[NSImage alloc] initWithSize:NSMakeSize(width, height)]

          autorelease];

       if (image) {

         [image addRepresentation:imageRep];

         retval =

           [[[NSCursor alloc] initWithImage:image

                                    hotSpot:NSMakePoint(mHotSpot.x, mHotSpot.y)]

            autorelease];

       }

     }

   }

   moz_free(data);

   // Fall back to an arrow cursor if (for some reason) the above code failed.

   if (!retval) {

     retval = [NSCursor arrowCursor];

   }

   return retval;

 }

 NSCursorInfo::Type NSCursorInfo::GetType() const

 {

   return mType;

 }

 const char* NSCursorInfo::GetTypeName() const

 {

   switch(mType) {

     case TypeCustom:

       return "TypeCustom";

     case TypeArrow:

       return "TypeArrow";

     case TypeClosedHand:

       return "TypeClosedHand";

     case TypeContextualMenu:

       return "TypeContextualMenu";

     case TypeCrosshair:

       return "TypeCrosshair";

     case TypeDisappearingItem:

       return "TypeDisappearingItem";

     case TypeDragCopy:

       return "TypeDragCopy";

     case TypeDragLink:

       return "TypeDragLink";

     case TypeIBeam:

       return "TypeIBeam";

     case TypeNotAllowed:

       return "TypeNotAllowed";

     case TypeOpenHand:

       return "TypeOpenHand";

     case TypePointingHand:

       return "TypePointingHand";

     case TypeResizeDown:

       return "TypeResizeDown";

     case TypeResizeLeft:

       return "TypeResizeLeft";

     case TypeResizeLeftRight:

       return "TypeResizeLeftRight";

     case TypeResizeRight:

       return "TypeResizeRight";

     case TypeResizeUp:

       return "TypeResizeUp";

     case TypeResizeUpDown:

       return "TypeResizeUpDown";

     case TypeTransparent:

       return "TypeTransparent";

     default:

       break;

   }

   return "TypeUnknown";

 }

 nsPoint NSCursorInfo::GetHotSpot() const

 {

   return mHotSpot;

 }

 uint8_t* NSCursorInfo::GetCustomImageData() const

 {

   return mCustomImageData;

 }

 uint32_t NSCursorInfo::GetCustomImageDataLength() const

 {

   return mCustomImageDataLength;

 }

 void NSCursorInfo::SetType(Type aType)

 {

   mType = aType;

 }

 void NSCursorInfo::SetHotSpot(nsPoint aHotSpot)

 {

   mHotSpot = aHotSpot;

 }

 void NSCursorInfo::SetCustomImageData(uint8_t* aData, uint32_t aDataLength)

 {

   if (mCustomImageData) {

     moz_free(mCustomImageData);

   }

   if (aDataLength) {

     mCustomImageData = (uint8_t*) moz_xmalloc(aDataLength);

     memcpy(mCustomImageData, aData, aDataLength);

   } else {

     mCustomImageData = NULL;

   }

   mCustomImageDataLength = aDataLength;

 }

 // This should never be called from the browser process -- only from the

 // plugin process.

 bool NSCursorInfo::GetNativeCursorsSupported()

 {

   if (mNativeCursorsSupported == -1) {

     AssertPluginThread();

     PluginModuleChild *pmc = PluginModuleChild::current();

     if (pmc) {

       bool result = pmc->GetNativeCursorsSupported();

       if (result) {

         mNativeCursorsSupported = 1;

       } else {

         mNativeCursorsSupported = 0;

       }

     }

   }

   return (mNativeCursorsSupported == 1);

 }

 } // namespace mac_plugin_interposing

 namespace mac_plugin_interposing {

 namespace parent {

 // Tracks plugin windows currently visible.

 std::set<uint32_t> plugin_visible_windows_set_;

 // Tracks full screen windows currently visible.

 std::set<uint32_t> plugin_fullscreen_windows_set_;

 // Tracks modal windows currently visible.

 std::set<uint32_t> plugin_modal_windows_set_;

 void OnPluginShowWindow(uint32_t window_id,

                         CGRect window_bounds,

                         bool modal) {

   plugin_visible_windows_set_.insert(window_id);

   if (modal)

     plugin_modal_windows_set_.insert(window_id);

   CGRect main_display_bounds = ::CGDisplayBounds(CGMainDisplayID());

   if (CGRectEqualToRect(window_bounds, main_display_bounds) &&

       (plugin_fullscreen_windows_set_.find(window_id) ==

        plugin_fullscreen_windows_set_.end())) {

     plugin_fullscreen_windows_set_.insert(window_id);

     nsCocoaUtils::HideOSChromeOnScreen(TRUE, [[NSScreen screens] objectAtIndex:0]);

   }

 }

 static void ActivateProcess(pid_t pid) {

   ProcessSerialNumber process;

   OSStatus status = ::GetProcessForPID(pid, &process);

   if (status == noErr) {

     SetFrontProcess(&process);

   } else {

     NS_WARNING("Unable to get process for pid.");

   }

 }

 // Must be called on the UI thread.

 // If plugin_pid is -1, the browser will be the active process on return,

 // otherwise that process will be given focus back before this function returns.

 static void ReleasePluginFullScreen(pid_t plugin_pid) {

   // Releasing full screen only works if we are the frontmost process; grab

   // focus, but give it back to the plugin process if requested.

   ActivateProcess(base::GetCurrentProcId());

   nsCocoaUtils::HideOSChromeOnScreen(FALSE, [[NSScreen screens] objectAtIndex:0]);

   if (plugin_pid != -1) {

     ActivateProcess(plugin_pid);

   }

 }

 void OnPluginHideWindow(uint32_t window_id, pid_t aPluginPid) {

   bool had_windows = !plugin_visible_windows_set_.empty();

   plugin_visible_windows_set_.erase(window_id);

   bool browser_needs_activation = had_windows &&

       plugin_visible_windows_set_.empty();

   plugin_modal_windows_set_.erase(window_id);

   if (plugin_fullscreen_windows_set_.find(window_id) !=

       plugin_fullscreen_windows_set_.end()) {

     plugin_fullscreen_windows_set_.erase(window_id);

     pid_t plugin_pid = browser_needs_activation ? -1 : aPluginPid;

     browser_needs_activation = false;

     ReleasePluginFullScreen(plugin_pid);

   }

   if (browser_needs_activation) {

     ActivateProcess(getpid());

   }

 }

 void OnSetCursor(const NSCursorInfo& cursorInfo)

 {

   NSCursor* aCursor = cursorInfo.GetNSCursor();

   if (aCursor) {

     [aCursor set];

   }

 }

 void OnShowCursor(bool show)

 {

   if (show) {

     [NSCursor unhide];

   } else {

     [NSCursor hide];

   }

 }

 void OnPushCursor(const NSCursorInfo& cursorInfo)

 {

   NSCursor* aCursor = cursorInfo.GetNSCursor();

   if (aCursor) {

     [aCursor push];

   }

 }

 void OnPopCursor()

 {

   [NSCursor pop];

 }

 } // parent

 } // namespace mac_plugin_interposing

 namespace mac_plugin_interposing {

 namespace child {

 // TODO(stuartmorgan): Make this an IPC to order the plugin process above the

 // browser process only if the browser is current frontmost.

 void FocusPluginProcess() {

   ProcessSerialNumber this_process, front_process;

   if ((GetCurrentProcess(&this_process) != noErr) ||

       (GetFrontProcess(&front_process) != noErr)) {

     return;

   }

   Boolean matched = false;

   if ((SameProcess(&this_process, &front_process, &matched) == noErr) &&

       !matched) {

     SetFrontProcess(&this_process);

   }

 }

 void NotifyBrowserOfPluginShowWindow(uint32_t window_id, CGRect bounds,

                                      bool modal) {

   AssertPluginThread();

   PluginModuleChild *pmc = PluginModuleChild::current();

   if (pmc)

     pmc->PluginShowWindow(window_id, modal, bounds);

 }

 void NotifyBrowserOfPluginHideWindow(uint32_t window_id, CGRect bounds) {

   AssertPluginThread();

   PluginModuleChild *pmc = PluginModuleChild::current();

   if (pmc)

     pmc->PluginHideWindow(window_id);

 }

 void NotifyBrowserOfSetCursor(NSCursorInfo& aCursorInfo)

 {

   AssertPluginThread();

   PluginModuleChild *pmc = PluginModuleChild::current();

   if (pmc) {

     pmc->SetCursor(aCursorInfo);

   }

 }

 void NotifyBrowserOfShowCursor(bool show)

 {

   AssertPluginThread();

   PluginModuleChild *pmc = PluginModuleChild::current();

   if (pmc) {

     pmc->ShowCursor(show);

   }

 }

 void NotifyBrowserOfPushCursor(NSCursorInfo& aCursorInfo)

 {

   AssertPluginThread();

   PluginModuleChild *pmc = PluginModuleChild::current();

   if (pmc) {

     pmc->PushCursor(aCursorInfo);

   }

 }

 void NotifyBrowserOfPopCursor()

 {

   AssertPluginThread();

   PluginModuleChild *pmc = PluginModuleChild::current();

   if (pmc) {

     pmc->PopCursor();

   }

 }

 struct WindowInfo {

   uint32_t window_id;

   CGRect bounds;

   WindowInfo(NSWindow* window) {

     NSInteger window_num = [window windowNumber];

     window_id = window_num > 0 ? window_num : 0;

     bounds = NSRectToCGRect([window frame]);

   }

 };

 static void OnPluginWindowClosed(const WindowInfo& window_info) {

   if (window_info.window_id == 0)

     return;

   mac_plugin_interposing::child::NotifyBrowserOfPluginHideWindow(window_info.window_id,

                                                                  window_info.bounds);

 }

 static void OnPluginWindowShown(const WindowInfo& window_info, BOOL is_modal) {

   // The window id is 0 if it has never been shown (including while it is the

   // process of being shown for the first time); when that happens, we'll catch

   // it in _setWindowNumber instead.

   static BOOL s_pending_display_is_modal = NO;

   if (window_info.window_id == 0) {

     if (is_modal)

       s_pending_display_is_modal = YES;

     return;

   }

   if (s_pending_display_is_modal) {

     is_modal = YES;

     s_pending_display_is_modal = NO;

   }

   mac_plugin_interposing::child::NotifyBrowserOfPluginShowWindow(

     window_info.window_id, window_info.bounds, is_modal);

 }

 static BOOL OnSetCursor(NSCursorInfo &aInfo)

 {

   if (NSCursorInfo::GetNativeCursorsSupported()) {

     NotifyBrowserOfSetCursor(aInfo);

     return YES;

   }

   return NO;

 }

 static BOOL OnHideCursor()

 {

   if (NSCursorInfo::GetNativeCursorsSupported()) {

     NotifyBrowserOfShowCursor(NO);

     return YES;

   }

   return NO;

 }

 static BOOL OnUnhideCursor()

 {

   if (NSCursorInfo::GetNativeCursorsSupported()) {

     NotifyBrowserOfShowCursor(YES);

     return YES;

   }

   return NO;

 }

 static BOOL OnPushCursor(NSCursorInfo &aInfo)

 {

   if (NSCursorInfo::GetNativeCursorsSupported()) {

     NotifyBrowserOfPushCursor(aInfo);

     return YES;

   }

   return NO;

 }

 static BOOL OnPopCursor()

 {

   if (NSCursorInfo::GetNativeCursorsSupported()) {

     NotifyBrowserOfPopCursor();

     return YES;

   }

   return NO;

 }

 } // child

 } // namespace mac_plugin_interposing

 using namespace mac_plugin_interposing::child;

 @interface NSWindow (PluginInterposing)

 - (void)pluginInterpose_orderOut:(id)sender;

 - (void)pluginInterpose_orderFront:(id)sender;

 - (void)pluginInterpose_makeKeyAndOrderFront:(id)sender;

 - (void)pluginInterpose_setWindowNumber:(NSInteger)num;

 @end

 @implementation NSWindow (PluginInterposing)

 - (void)pluginInterpose_orderOut:(id)sender {

   WindowInfo window_info(self);

   [self pluginInterpose_orderOut:sender];

   OnPluginWindowClosed(window_info);

 }

 - (void)pluginInterpose_orderFront:(id)sender {

   mac_plugin_interposing::child::FocusPluginProcess();

   [self pluginInterpose_orderFront:sender];

   OnPluginWindowShown(WindowInfo(self), NO);

 }

 - (void)pluginInterpose_makeKeyAndOrderFront:(id)sender {

   mac_plugin_interposing::child::FocusPluginProcess();

   [self pluginInterpose_makeKeyAndOrderFront:sender];

   OnPluginWindowShown(WindowInfo(self), NO);

 }

 - (void)pluginInterpose_setWindowNumber:(NSInteger)num {

   if (num > 0)

     mac_plugin_interposing::child::FocusPluginProcess();

   [self pluginInterpose_setWindowNumber:num];

   if (num > 0)

     OnPluginWindowShown(WindowInfo(self), NO);

 }

 @end

 @interface NSApplication (PluginInterposing)

 - (NSInteger)pluginInterpose_runModalForWindow:(NSWindow*)window;

 @end

 @implementation NSApplication (PluginInterposing)

 - (NSInteger)pluginInterpose_runModalForWindow:(NSWindow*)window {

   mac_plugin_interposing::child::FocusPluginProcess();

   // This is out-of-order relative to the other calls, but runModalForWindow:

   // won't return until the window closes, and the order only matters for

   // full-screen windows.

   OnPluginWindowShown(WindowInfo(window), YES);

   return [self pluginInterpose_runModalForWindow:window];

 }

 @end

 // Hook commands to manipulate the current cursor, so that they can be passed

 // from the child process to the parent process.  These commands have no

 // effect unless they're performed in the parent process.

 @interface NSCursor (PluginInterposing)

 - (void)pluginInterpose_set;

 - (void)pluginInterpose_push;

 - (void)pluginInterpose_pop;

 + (NSCursor*)pluginInterpose_currentCursor;

 + (void)pluginInterpose_hide;

 + (void)pluginInterpose_unhide;

 + (void)pluginInterpose_pop;

 @end

 // Cache the results of [NSCursor set], [NSCursor push] and [NSCursor pop].

 // The last element is always the current cursor.

 static NSMutableArray* gCursorStack = nil;

 static BOOL initCursorStack()

 {

   if (!gCursorStack) {

     gCursorStack = [[NSMutableArray arrayWithCapacity:5] retain];

   }

   return (gCursorStack != NULL);

 }

 static NSCursor* currentCursorFromCache()

 {

   if (!initCursorStack())

     return nil;

   return (NSCursor*) [gCursorStack lastObject];

 }

 static void setCursorInCache(NSCursor* aCursor)

 {

   if (!initCursorStack() || !aCursor)

     return;

   NSUInteger count = [gCursorStack count];

   if (count) {

     [gCursorStack replaceObjectAtIndex:count - 1 withObject:aCursor];

   } else {

     [gCursorStack addObject:aCursor];

   }

 }

 static void pushCursorInCache(NSCursor* aCursor)

 {

   if (!initCursorStack() || !aCursor)

     return;

   [gCursorStack addObject:aCursor];

 }

 static void popCursorInCache()

 {

   if (!initCursorStack())

     return;

   // Apple's doc on the +[NSCursor pop] method says:  "If the current cursor

   // is the only cursor on the stack, this method does nothing."

   if ([gCursorStack count] > 1) {

     [gCursorStack removeLastObject];

   }

 }

 @implementation NSCursor (PluginInterposing)

 - (void)pluginInterpose_set

 {

   NSCursorInfo info(self);

   OnSetCursor(info);

   setCursorInCache(self);

   [self pluginInterpose_set];

 }

 - (void)pluginInterpose_push

 {

   NSCursorInfo info(self);

   OnPushCursor(info);

   pushCursorInCache(self);

   [self pluginInterpose_push];

 }

 - (void)pluginInterpose_pop

 {

   OnPopCursor();

   popCursorInCache();

   [self pluginInterpose_pop];

 }

 // The currentCursor method always returns nil when running in a background

 // process.  But this may confuse plugins (notably Flash, see bug 621117).  So

 // if we get a nil return from the "call to super", we return a cursor that's

 // been cached by previous calls to set or push.  According to Apple's docs,

 // currentCursor "only returns the cursor set by your application using

 // NSCursor methods".  So we don't need to worry about changes to the cursor

 // made by other methods like SetThemeCursor().

 + (NSCursor*)pluginInterpose_currentCursor

 {

   NSCursor* retval = [self pluginInterpose_currentCursor];

   if (!retval) {

     retval = currentCursorFromCache();

   }

   return retval;

 }

 + (void)pluginInterpose_hide

 {

   OnHideCursor();

   [self pluginInterpose_hide];

 }

 + (void)pluginInterpose_unhide

 {

   OnUnhideCursor();

   [self pluginInterpose_unhide];

 }

 + (void)pluginInterpose_pop

 {

   OnPopCursor();

   popCursorInCache();

   [self pluginInterpose_pop];

 }

 @end

 static void ExchangeMethods(Class target_class,

                             BOOL class_method,

                             SEL original,

                             SEL replacement) {

   Method m1;

   Method m2;

   if (class_method) {

     m1 = class_getClassMethod(target_class, original);

     m2 = class_getClassMethod(target_class, replacement);

   } else {

     m1 = class_getInstanceMethod(target_class, original);

     m2 = class_getInstanceMethod(target_class, replacement);

   }

   if (m1 == m2)

     return;

   if (m1 && m2)

     method_exchangeImplementations(m1, m2);

   else

     NS_NOTREACHED("Cocoa swizzling failed");

 }

 namespace mac_plugin_interposing {

 namespace child {

 void SetUpCocoaInterposing() {

   Class nswindow_class = [NSWindow class];

   ExchangeMethods(nswindow_class, NO, @selector(orderOut:),

                   @selector(pluginInterpose_orderOut:));

   ExchangeMethods(nswindow_class, NO, @selector(orderFront:),

                   @selector(pluginInterpose_orderFront:));

   ExchangeMethods(nswindow_class, NO, @selector(makeKeyAndOrderFront:),

                   @selector(pluginInterpose_makeKeyAndOrderFront:));

   ExchangeMethods(nswindow_class, NO, @selector(_setWindowNumber:),

                   @selector(pluginInterpose_setWindowNumber:));

   ExchangeMethods([NSApplication class], NO, @selector(runModalForWindow:),

                   @selector(pluginInterpose_runModalForWindow:));

   Class nscursor_class = [NSCursor class];

   ExchangeMethods(nscursor_class, NO, @selector(set),

                   @selector(pluginInterpose_set));

   ExchangeMethods(nscursor_class, NO, @selector(push),

                   @selector(pluginInterpose_push));

   ExchangeMethods(nscursor_class, NO, @selector(pop),

                   @selector(pluginInterpose_pop));

   ExchangeMethods(nscursor_class, YES, @selector(currentCursor),

                   @selector(pluginInterpose_currentCursor));

   ExchangeMethods(nscursor_class, YES, @selector(hide),

                   @selector(pluginInterpose_hide));

   ExchangeMethods(nscursor_class, YES, @selector(unhide),

                   @selector(pluginInterpose_unhide));

   ExchangeMethods(nscursor_class, YES, @selector(pop),

                   @selector(pluginInterpose_pop));

 }

 }  // namespace child

 }  // namespace mac_plugin_interposing

 // Called from plugin_child_interpose.mm, which hooks calls to

 // SetCursor() (the QuickDraw call) from the plugin child process.

 extern "C" NS_VISIBILITY_DEFAULT BOOL

 mac_plugin_interposing_child_OnSetCursor(const Cursor* cursor)

 {

   NSCursorInfo info(cursor);

   return OnSetCursor(info);

 }

 // Called from plugin_child_interpose.mm, which hooks calls to

 // SetThemeCursor() (the Appearance Manager call) from the plugin child

 // process.

 extern "C" NS_VISIBILITY_DEFAULT BOOL

 mac_plugin_interposing_child_OnSetThemeCursor(ThemeCursor cursor)

 {

   NSCursorInfo info;

   switch (cursor) {

     case kThemeArrowCursor:

       info.SetType(NSCursorInfo::TypeArrow);

       break;

     case kThemeCopyArrowCursor:

       info.SetType(NSCursorInfo::TypeDragCopy);

       break;

     case kThemeAliasArrowCursor:

       info.SetType(NSCursorInfo::TypeDragLink);

       break;

     case kThemeContextualMenuArrowCursor:

       info.SetType(NSCursorInfo::TypeContextualMenu);

       break;

     case kThemeIBeamCursor:

       info.SetType(NSCursorInfo::TypeIBeam);

       break;

     case kThemeCrossCursor:

     case kThemePlusCursor:

       info.SetType(NSCursorInfo::TypeCrosshair);

       break;

     case kThemeWatchCursor:

     case kThemeSpinningCursor:

       info.SetType(NSCursorInfo::TypeArrow);

       break;

     case kThemeClosedHandCursor:

       info.SetType(NSCursorInfo::TypeClosedHand);

       break;

     case kThemeOpenHandCursor:

       info.SetType(NSCursorInfo::TypeOpenHand);

       break;

     case kThemePointingHandCursor:

     case kThemeCountingUpHandCursor:

     case kThemeCountingDownHandCursor:

     case kThemeCountingUpAndDownHandCursor:

       info.SetType(NSCursorInfo::TypePointingHand);

       break;

     case kThemeResizeLeftCursor:

       info.SetType(NSCursorInfo::TypeResizeLeft);

       break;

     case kThemeResizeRightCursor:

       info.SetType(NSCursorInfo::TypeResizeRight);

       break;

     case kThemeResizeLeftRightCursor:

       info.SetType(NSCursorInfo::TypeResizeLeftRight);

       break;

     case kThemeNotAllowedCursor:

       info.SetType(NSCursorInfo::TypeNotAllowed);

       break;

     case kThemeResizeUpCursor:

       info.SetType(NSCursorInfo::TypeResizeUp);

       break;

     case kThemeResizeDownCursor:

       info.SetType(NSCursorInfo::TypeResizeDown);

       break;

     case kThemeResizeUpDownCursor:

       info.SetType(NSCursorInfo::TypeResizeUpDown);

       break;

     case kThemePoofCursor:

       info.SetType(NSCursorInfo::TypeDisappearingItem);

       break;

     default:

       info.SetType(NSCursorInfo::TypeArrow);

       break;

   }

   return OnSetCursor(info);

 }

 extern "C" NS_VISIBILITY_DEFAULT BOOL

 mac_plugin_interposing_child_OnHideCursor()

 {

   return OnHideCursor();

 }

 extern "C" NS_VISIBILITY_DEFAULT BOOL

 mac_plugin_interposing_child_OnShowCursor()

 {

   return OnUnhideCursor();

 }