The Tor Browser: dom/plugins/ipc/PluginInstanceParent.cpp@6474c204b198

Cloned upstream origin tor-browser at tor-browser-31.3.0esr-4.5-1-build1
revision ID fc1c9ff7c1b2defdbc039f12214767608f46423f for hacking purpose.

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

     2  * vim: sw=4 ts=4 et :

     3  * This Source Code Form is subject to the terms of the Mozilla Public

     4  * License, v. 2.0. If a copy of the MPL was not distributed with this

     5  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

     7 #include "mozilla/DebugOnly.h"

     8 #include <stdint.h> // for intptr_t

    10 #include "PluginInstanceParent.h"

    11 #include "BrowserStreamParent.h"

    12 #include "PluginBackgroundDestroyer.h"

    13 #include "PluginModuleParent.h"

    14 #include "PluginStreamParent.h"

    15 #include "StreamNotifyParent.h"

    16 #include "npfunctions.h"

    17 #include "nsAutoPtr.h"

    18 #include "gfxASurface.h"

    19 #include "gfxContext.h"

    20 #include "gfxPlatform.h"

    21 #include "gfxSharedImageSurface.h"

    22 #include "nsNPAPIPluginInstance.h"

    23 #ifdef MOZ_X11

    24 #include "gfxXlibSurface.h"

    25 #endif

    26 #include "gfxContext.h"

    27 #include "gfxColor.h"

    28 #include "gfxUtils.h"

    29 #include "mozilla/gfx/2D.h"

    30 #include "Layers.h"

    31 #include "SharedTextureImage.h"

    32 #include "GLContext.h"

    33 #include "GLContextProvider.h"

    35 #ifdef XP_MACOSX

    36 #include "MacIOSurfaceImage.h"

    37 #endif

    39 #if defined(OS_WIN)

    40 #include <windowsx.h>

    41 #include "gfxWindowsPlatform.h"

    42 #include "mozilla/plugins/PluginSurfaceParent.h"

    44 // Plugin focus event for widget.

    45 extern const wchar_t* kOOPPPluginFocusEventId;

    46 UINT gOOPPPluginFocusEvent =

    47     RegisterWindowMessage(kOOPPPluginFocusEventId);

    48 extern const wchar_t* kFlashFullscreenClass;

    49 #elif defined(MOZ_WIDGET_GTK)

    50 #include <gdk/gdk.h>

    51 #elif defined(XP_MACOSX)

    52 #include <ApplicationServices/ApplicationServices.h>

    53 #endif // defined(XP_MACOSX)

    55 using namespace mozilla::plugins;

    56 using namespace mozilla::layers;

    57 using namespace mozilla::gl;

    59 bool

    60 StreamNotifyParent::RecvRedirectNotifyResponse(const bool& allow)

    61 {

    62   PluginInstanceParent* instance = static_cast<PluginInstanceParent*>(Manager());

    63   instance->mNPNIface->urlredirectresponse(instance->mNPP, this, static_cast<NPBool>(allow));

    64   return true;

    65 }

    67 PluginInstanceParent::PluginInstanceParent(PluginModuleParent* parent,

    68                                            NPP npp,

    69                                            const nsCString& aMimeType,

    70                                            const NPNetscapeFuncs* npniface)

    71   : mParent(parent)

    72     , mNPP(npp)

    73     , mNPNIface(npniface)

    74     , mWindowType(NPWindowTypeWindow)

    75     , mDrawingModel(kDefaultDrawingModel)

    76 #if defined(OS_WIN)

    77     , mPluginHWND(nullptr)

    78     , mPluginWndProc(nullptr)

    79     , mNestedEventState(false)

    80 #endif // defined(XP_WIN)

    81 #if defined(XP_MACOSX)

    82     , mShWidth(0)

    83     , mShHeight(0)

    84     , mShColorSpace(nullptr)

    85 #endif

    86 {

    87 }

    89 PluginInstanceParent::~PluginInstanceParent()

    90 {

    91     if (mNPP)

    92         mNPP->pdata = nullptr;

    94 #if defined(OS_WIN)

    95     NS_ASSERTION(!(mPluginHWND || mPluginWndProc),

    96         "Subclass was not reset correctly before the dtor was reached!");

    97 #endif

    98 #if defined(MOZ_WIDGET_COCOA)

    99     if (mShWidth != 0 && mShHeight != 0) {

   100         DeallocShmem(mShSurface);

   101     }

   102     if (mShColorSpace)

   103         ::CGColorSpaceRelease(mShColorSpace);

   104 #endif

   105     if (mRemoteImageDataShmem.IsWritable()) {

   106         if (mImageContainer) {

   107             mImageContainer->SetRemoteImageData(nullptr, nullptr);

   108             mImageContainer->SetCompositionNotifySink(nullptr);

   109         }

   110         DeallocShmem(mRemoteImageDataShmem);

   111     }

   112 }

   114 bool

   115 PluginInstanceParent::Init()

   116 {

   117     return true;

   118 }

   120 void

   121 PluginInstanceParent::ActorDestroy(ActorDestroyReason why)

   122 {

   123 #if defined(OS_WIN)

   124     if (why == AbnormalShutdown) {

   125         // If the plugin process crashes, this is the only

   126         // chance we get to destroy resources.

   127         SharedSurfaceRelease();

   128         UnsubclassPluginWindow();

   129     }

   130 #endif

   131     // After this method, the data backing the remote surface may no

   132     // longer be valid. The X surface may be destroyed, or the shared

   133     // memory backing this surface may no longer be valid.

   134     if (mFrontSurface) {

   135         mFrontSurface = nullptr;

   136         if (mImageContainer) {

   137             mImageContainer->SetCurrentImage(nullptr);

   138         }

   139 #ifdef MOZ_X11

   140         FinishX(DefaultXDisplay());

   141 #endif

   142     }

   143 }

   145 NPError

   146 PluginInstanceParent::Destroy()

   147 {

   148     NPError retval;

   149     if (!CallNPP_Destroy(&retval))

   150         retval = NPERR_GENERIC_ERROR;

   152 #if defined(OS_WIN)

   153     SharedSurfaceRelease();

   154     UnsubclassPluginWindow();

   155 #endif

   157     return retval;

   158 }

   160 PBrowserStreamParent*

   161 PluginInstanceParent::AllocPBrowserStreamParent(const nsCString& url,

   162                                                 const uint32_t& length,

   163                                                 const uint32_t& lastmodified,

   164                                                 PStreamNotifyParent* notifyData,

   165                                                 const nsCString& headers,

   166                                                 const nsCString& mimeType,

   167                                                 const bool& seekable,

   168                                                 NPError* rv,

   169                                                 uint16_t *stype)

   170 {

   171     NS_RUNTIMEABORT("Not reachable");

   172     return nullptr;

   173 }

   175 bool

   176 PluginInstanceParent::DeallocPBrowserStreamParent(PBrowserStreamParent* stream)

   177 {

   178     delete stream;

   179     return true;

   180 }

   182 PPluginStreamParent*

   183 PluginInstanceParent::AllocPPluginStreamParent(const nsCString& mimeType,

   184                                                const nsCString& target,

   185                                                NPError* result)

   186 {

   187     return new PluginStreamParent(this, mimeType, target, result);

   188 }

   190 bool

   191 PluginInstanceParent::DeallocPPluginStreamParent(PPluginStreamParent* stream)

   192 {

   193     delete stream;

   194     return true;

   195 }

   197 bool

   198 PluginInstanceParent::AnswerNPN_GetValue_NPNVnetscapeWindow(NativeWindowHandle* value,

   199                                                             NPError* result)

   200 {

   201 #ifdef XP_WIN

   202     HWND id;

   203 #elif defined(MOZ_X11)

   204     XID id;

   205 #elif defined(XP_MACOSX)

   206     intptr_t id;

   207 #elif defined(ANDROID)

   208     // TODO: Need Android impl

   209     int id;

   210 #elif defined(MOZ_WIDGET_QT)

   211     // TODO: Need Qt non X impl

   212     int id;

   213 #else

   214 #warning Implement me

   215 #endif

   217     *result = mNPNIface->getvalue(mNPP, NPNVnetscapeWindow, &id);

   218     *value = id;

   219     return true;

   220 }

   222 bool

   223 PluginInstanceParent::InternalGetValueForNPObject(

   224                                          NPNVariable aVariable,

   225                                          PPluginScriptableObjectParent** aValue,

   226                                          NPError* aResult)

   227 {

   228     NPObject* npobject;

   229     NPError result = mNPNIface->getvalue(mNPP, aVariable, (void*)&npobject);

   230     if (result == NPERR_NO_ERROR) {

   231         NS_ASSERTION(npobject, "Shouldn't return null and NPERR_NO_ERROR!");

   233         PluginScriptableObjectParent* actor = GetActorForNPObject(npobject);

   234         mNPNIface->releaseobject(npobject);

   235         if (actor) {

   236             *aValue = actor;

   237             *aResult = NPERR_NO_ERROR;

   238             return true;

   239         }

   241         NS_ERROR("Failed to get actor!");

   242         result = NPERR_GENERIC_ERROR;

   243     }

   245     *aValue = nullptr;

   246     *aResult = result;

   247     return true;

   248 }

   250 bool

   251 PluginInstanceParent::IsAsyncDrawing()

   252 {

   253   return IsDrawingModelAsync(mDrawingModel);

   254 }

   256 bool

   257 PluginInstanceParent::AnswerNPN_GetValue_NPNVWindowNPObject(

   258                                          PPluginScriptableObjectParent** aValue,

   259                                          NPError* aResult)

   260 {

   261     return InternalGetValueForNPObject(NPNVWindowNPObject, aValue, aResult);

   262 }

   264 bool

   265 PluginInstanceParent::AnswerNPN_GetValue_NPNVPluginElementNPObject(

   266                                          PPluginScriptableObjectParent** aValue,

   267                                          NPError* aResult)

   268 {

   269     return InternalGetValueForNPObject(NPNVPluginElementNPObject, aValue,

   270                                        aResult);

   271 }

   273 bool

   274 PluginInstanceParent::AnswerNPN_GetValue_NPNVprivateModeBool(bool* value,

   275                                                              NPError* result)

   276 {

   277     NPBool v;

   278     *result = mNPNIface->getvalue(mNPP, NPNVprivateModeBool, &v);

   279     *value = v;

   280     return true;

   281 }

   283 bool

   284 PluginInstanceParent::AnswerNPN_GetValue_DrawingModelSupport(const NPNVariable& model, bool* value)

   285 {

   286     *value = false;

   288 #ifdef XP_WIN

   289     switch (model) {

   290         case NPNVsupportsAsyncWindowsDXGISurfaceBool: {

   291             if (gfxWindowsPlatform::GetPlatform()->GetRenderMode() == gfxWindowsPlatform::RENDER_DIRECT2D) {

   292                 *value = true;

   293             }

   294         }

   295     }

   296 #endif

   298     return true;

   299 }

   301 bool

   302 PluginInstanceParent::AnswerNPN_GetValue_NPNVdocumentOrigin(nsCString* value,

   303                                                             NPError* result)

   304 {

   305     void *v = nullptr;

   306     *result = mNPNIface->getvalue(mNPP, NPNVdocumentOrigin, &v);

   307     if (*result == NPERR_NO_ERROR && v) {

   308         value->Adopt(static_cast<char*>(v));

   309     }

   310     return true;

   311 }

   313 bool

   314 PluginInstanceParent::AnswerNPN_SetValue_NPPVpluginWindow(

   315     const bool& windowed, NPError* result)

   316 {

   317     // Yes, we are passing a boolean as a void*.  We have to cast to intptr_t

   318     // first to avoid gcc warnings about casting to a pointer from a

   319     // non-pointer-sized integer.

   320     *result = mNPNIface->setvalue(mNPP, NPPVpluginWindowBool,

   321                                   (void*)(intptr_t)windowed);

   322     return true;

   323 }

   325 bool

   326 PluginInstanceParent::AnswerNPN_SetValue_NPPVpluginTransparent(

   327     const bool& transparent, NPError* result)

   328 {

   329     *result = mNPNIface->setvalue(mNPP, NPPVpluginTransparentBool,

   330                                   (void*)(intptr_t)transparent);

   331     return true;

   332 }

   334 bool

   335 PluginInstanceParent::AnswerNPN_SetValue_NPPVpluginUsesDOMForCursor(

   336     const bool& useDOMForCursor, NPError* result)

   337 {

   338     *result = mNPNIface->setvalue(mNPP, NPPVpluginUsesDOMForCursorBool,

   339                                   (void*)(intptr_t)useDOMForCursor);

   340     return true;

   341 }

   343 class NotificationSink : public CompositionNotifySink

   344 {

   345 public:

   346   NotificationSink(PluginInstanceParent *aInstance) : mInstance(aInstance)

   347   { }

   349   virtual void DidComposite() { mInstance->DidComposite(); }

   350 private:

   351   PluginInstanceParent *mInstance;

   352 };

   354 bool

   355 PluginInstanceParent::AnswerNPN_SetValue_NPPVpluginDrawingModel(

   356     const int& drawingModel, OptionalShmem *shmem, CrossProcessMutexHandle *mutex, NPError* result)

   357 {

   358     *shmem = null_t();

   360 #ifdef XP_MACOSX

   361     if (drawingModel == NPDrawingModelCoreAnimation ||

   362         drawingModel == NPDrawingModelInvalidatingCoreAnimation) {

   363         // We need to request CoreGraphics otherwise

   364         // the nsObjectFrame will try to draw a CALayer

   365         // that can not be shared across process.

   366         mDrawingModel = drawingModel;

   367         *result = mNPNIface->setvalue(mNPP, NPPVpluginDrawingModel,

   368                                   (void*)NPDrawingModelCoreGraphics);

   369     } else

   370 #endif

   371     if (drawingModel == NPDrawingModelAsyncBitmapSurface

   372 #ifdef XP_WIN

   373         || drawingModel == NPDrawingModelAsyncWindowsDXGISurface

   374 #endif

   375         ) {

   376         ImageContainer *container = GetImageContainer();

   377         if (!container) {

   378             *result = NPERR_GENERIC_ERROR;

   379             return true;

   380         }

   382 #ifdef XP_WIN

   383         if (drawingModel == NPDrawingModelAsyncWindowsDXGISurface &&

   384             gfxWindowsPlatform::GetPlatform()->GetRenderMode() != gfxWindowsPlatform::RENDER_DIRECT2D) {

   385             *result = NPERR_GENERIC_ERROR;

   386             return true;

   387         }

   388 #endif

   390         mDrawingModel = drawingModel;

   391         *result = mNPNIface->setvalue(mNPP, NPPVpluginDrawingModel,

   392                                       reinterpret_cast<void*>(static_cast<uintptr_t>(drawingModel)));

   395         if (*result != NPERR_NO_ERROR) {

   396             return true;

   397         }

   399         AllocUnsafeShmem(sizeof(RemoteImageData), SharedMemory::TYPE_BASIC, &mRemoteImageDataShmem);

   401         *shmem = mRemoteImageDataShmem;

   403         mRemoteImageDataMutex = new CrossProcessMutex("PluginInstanceParent.mRemoteImageDataMutex");

   405         *mutex = mRemoteImageDataMutex->ShareToProcess(OtherProcess());

   406         container->SetRemoteImageData(mRemoteImageDataShmem.get<RemoteImageData>(), mRemoteImageDataMutex);

   408         mNotifySink = new NotificationSink(this);

   410         container->SetCompositionNotifySink(mNotifySink);

   411     } else if (

   412 #if defined(XP_WIN)

   413                drawingModel == NPDrawingModelSyncWin

   414 #elif defined(XP_MACOSX)

   415                drawingModel == NPDrawingModelOpenGL ||

   416                drawingModel == NPDrawingModelCoreGraphics

   417 #elif defined(MOZ_X11)

   418                drawingModel == NPDrawingModelSyncX

   419 #else

   420                false

   421 #endif

   422                ) {

   423         *shmem = null_t();

   425         mDrawingModel = drawingModel;

   426         *result = mNPNIface->setvalue(mNPP, NPPVpluginDrawingModel,

   427                                       (void*)(intptr_t)drawingModel);

   429         if (mRemoteImageDataShmem.IsWritable()) {

   430             if (mImageContainer) {

   431                 mImageContainer->SetRemoteImageData(nullptr, nullptr);

   432                 mImageContainer->SetCompositionNotifySink(nullptr);

   433             }

   434             DeallocShmem(mRemoteImageDataShmem);

   435             mRemoteImageDataMutex = nullptr;

   436         }

   437     } else {

   438         *result = NPERR_GENERIC_ERROR;

   439     }

   440     return true;

   441 }

   443 bool

   444 PluginInstanceParent::AnswerNPN_SetValue_NPPVpluginEventModel(

   445     const int& eventModel, NPError* result)

   446 {

   447 #ifdef XP_MACOSX

   448     *result = mNPNIface->setvalue(mNPP, NPPVpluginEventModel,

   449                                   (void*)(intptr_t)eventModel);

   450     return true;

   451 #else

   452     *result = NPERR_GENERIC_ERROR;

   453     return true;

   454 #endif

   455 }

   457 bool

   458 PluginInstanceParent::AnswerNPN_GetURL(const nsCString& url,

   459                                        const nsCString& target,

   460                                        NPError* result)

   461 {

   462     *result = mNPNIface->geturl(mNPP,

   463                                 NullableStringGet(url),

   464                                 NullableStringGet(target));

   465     return true;

   466 }

   468 bool

   469 PluginInstanceParent::AnswerNPN_PostURL(const nsCString& url,

   470                                         const nsCString& target,

   471                                         const nsCString& buffer,

   472                                         const bool& file,

   473                                         NPError* result)

   474 {

   475     *result = mNPNIface->posturl(mNPP, url.get(), NullableStringGet(target),

   476                                  buffer.Length(), buffer.get(), file);

   477     return true;

   478 }

   480 PStreamNotifyParent*

   481 PluginInstanceParent::AllocPStreamNotifyParent(const nsCString& url,

   482                                                const nsCString& target,

   483                                                const bool& post,

   484                                                const nsCString& buffer,

   485                                                const bool& file,

   486                                                NPError* result)

   487 {

   488     return new StreamNotifyParent();

   489 }

   491 bool

   492 PluginInstanceParent::AnswerPStreamNotifyConstructor(PStreamNotifyParent* actor,

   493                                                      const nsCString& url,

   494                                                      const nsCString& target,

   495                                                      const bool& post,

   496                                                      const nsCString& buffer,

   497                                                      const bool& file,

   498                                                      NPError* result)

   499 {

   500     bool streamDestroyed = false;

   501     static_cast<StreamNotifyParent*>(actor)->

   502         SetDestructionFlag(&streamDestroyed);

   504     if (!post) {

   505         *result = mNPNIface->geturlnotify(mNPP,

   506                                           NullableStringGet(url),

   507                                           NullableStringGet(target),

   508                                           actor);

   509     }

   510     else {

   511         *result = mNPNIface->posturlnotify(mNPP,

   512                                            NullableStringGet(url),

   513                                            NullableStringGet(target),

   514                                            buffer.Length(),

   515                                            NullableStringGet(buffer),

   516                                            file, actor);

   517     }

   519     if (streamDestroyed) {

   520         // If the stream was destroyed, we must return an error code in the

   521         // constructor.

   522         *result = NPERR_GENERIC_ERROR;

   523     }

   524     else {

   525         static_cast<StreamNotifyParent*>(actor)->ClearDestructionFlag();

   526         if (*result != NPERR_NO_ERROR)

   527             return PStreamNotifyParent::Send__delete__(actor,

   528                                                        NPERR_GENERIC_ERROR);

   529     }

   531     return true;

   532 }

   534 bool

   535 PluginInstanceParent::DeallocPStreamNotifyParent(PStreamNotifyParent* notifyData)

   536 {

   537     delete notifyData;

   538     return true;

   539 }

   541 bool

   542 PluginInstanceParent::RecvNPN_InvalidateRect(const NPRect& rect)

   543 {

   544     mNPNIface->invalidaterect(mNPP, const_cast<NPRect*>(&rect));

   545     return true;

   546 }

   548 bool

   549 PluginInstanceParent::RecvShow(const NPRect& updatedRect,

   550                                const SurfaceDescriptor& newSurface,

   551                                SurfaceDescriptor* prevSurface)

   552 {

   553     PLUGIN_LOG_DEBUG(

   554         ("[InstanceParent][%p] RecvShow for <x=%d,y=%d, w=%d,h=%d>",

   555          this, updatedRect.left, updatedRect.top,

   556          updatedRect.right - updatedRect.left,

   557          updatedRect.bottom - updatedRect.top));

   559     // XXXjwatt rewrite to use Moz2D

   560     nsRefPtr<gfxASurface> surface;

   561     if (newSurface.type() == SurfaceDescriptor::TShmem) {

   562         if (!newSurface.get_Shmem().IsReadable()) {

   563             NS_WARNING("back surface not readable");

   564             return false;

   565         }

   566         surface = gfxSharedImageSurface::Open(newSurface.get_Shmem());

   567     }

   568 #ifdef XP_MACOSX

   569     else if (newSurface.type() == SurfaceDescriptor::TIOSurfaceDescriptor) {

   570         IOSurfaceDescriptor iodesc = newSurface.get_IOSurfaceDescriptor();

   572         RefPtr<MacIOSurface> newIOSurface =

   573           MacIOSurface::LookupSurface(iodesc.surfaceId(),

   574                                       iodesc.contentsScaleFactor());

   576         if (!newIOSurface) {

   577             NS_WARNING("Got bad IOSurfaceDescriptor in RecvShow");

   578             return false;

   579         }

   581         if (mFrontIOSurface)

   582             *prevSurface = IOSurfaceDescriptor(mFrontIOSurface->GetIOSurfaceID(),

   583                                                mFrontIOSurface->GetContentsScaleFactor());

   584         else

   585             *prevSurface = null_t();

   587         mFrontIOSurface = newIOSurface;

   589         RecvNPN_InvalidateRect(updatedRect);

   591         PLUGIN_LOG_DEBUG(("   (RecvShow invalidated for surface %p)",

   592                           mFrontSurface.get()));

   594         return true;

   595     }

   596 #endif

   597 #ifdef MOZ_X11

   598     else if (newSurface.type() == SurfaceDescriptor::TSurfaceDescriptorX11) {

   599         surface = newSurface.get_SurfaceDescriptorX11().OpenForeign();

   600     }

   601 #endif

   602 #ifdef XP_WIN

   603     else if (newSurface.type() == SurfaceDescriptor::TPPluginSurfaceParent) {

   604         PluginSurfaceParent* s =

   605             static_cast<PluginSurfaceParent*>(newSurface.get_PPluginSurfaceParent());

   606         surface = s->Surface();

   607     }

   608 #endif

   610     if (mFrontSurface) {

   611         // This is the "old front buffer" we're about to hand back to

   612         // the plugin.  We might still have drawing operations

   613         // referencing it.

   614 #ifdef MOZ_X11

   615         if (mFrontSurface->GetType() == gfxSurfaceType::Xlib) {

   616             // Finish with the surface and XSync here to ensure the server has

   617             // finished operations on the surface before the plugin starts

   618             // scribbling on it again, or worse, destroys it.

   619             mFrontSurface->Finish();

   620             FinishX(DefaultXDisplay());

   621         } else

   622 #endif

   623         {

   624             mFrontSurface->Flush();

   625         }

   626     }

   628     if (mFrontSurface && gfxSharedImageSurface::IsSharedImage(mFrontSurface))

   629         *prevSurface = static_cast<gfxSharedImageSurface*>(mFrontSurface.get())->GetShmem();

   630     else

   631         *prevSurface = null_t();

   633     if (surface) {

   634         // Notify the cairo backend that this surface has changed behind

   635         // its back.

   636         gfxRect ur(updatedRect.left, updatedRect.top,

   637                    updatedRect.right - updatedRect.left,

   638                    updatedRect.bottom - updatedRect.top);

   639         surface->MarkDirty(ur);

   641         ImageContainer *container = GetImageContainer();

   642         nsRefPtr<Image> image = container->CreateImage(ImageFormat::CAIRO_SURFACE);

   643         NS_ASSERTION(image->GetFormat() == ImageFormat::CAIRO_SURFACE, "Wrong format?");

   644         CairoImage* cairoImage = static_cast<CairoImage*>(image.get());

   645         CairoImage::Data cairoData;

   646         cairoData.mSize = surface->GetSize().ToIntSize();

   647         cairoData.mSourceSurface = gfxPlatform::GetPlatform()->GetSourceSurfaceForSurface(nullptr, surface);

   648         cairoImage->SetData(cairoData);

   650         container->SetCurrentImage(cairoImage);

   651     }

   652     else if (mImageContainer) {

   653         mImageContainer->SetCurrentImage(nullptr);

   654     }

   656     mFrontSurface = surface;

   657     RecvNPN_InvalidateRect(updatedRect);

   659     PLUGIN_LOG_DEBUG(("   (RecvShow invalidated for surface %p)",

   660                       mFrontSurface.get()));

   662     return true;

   663 }

   665 nsresult

   666 PluginInstanceParent::AsyncSetWindow(NPWindow* aWindow)

   667 {

   668     NPRemoteWindow window;

   669     mWindowType = aWindow->type;

   670     window.window = reinterpret_cast<uint64_t>(aWindow->window);

   671     window.x = aWindow->x;

   672     window.y = aWindow->y;

   673     window.width = aWindow->width;

   674     window.height = aWindow->height;

   675     window.clipRect = aWindow->clipRect;

   676     window.type = aWindow->type;

   677 #ifdef XP_MACOSX

   678     double scaleFactor = 1.0;

   679     mNPNIface->getvalue(mNPP, NPNVcontentsScaleFactor, &scaleFactor);

   680     window.contentsScaleFactor = scaleFactor;

   681 #endif

   682     if (!SendAsyncSetWindow(gfxPlatform::GetPlatform()->ScreenReferenceSurface()->GetType(),

   683                             window))

   684         return NS_ERROR_FAILURE;

   686     return NS_OK;

   687 }

   689 nsresult

   690 PluginInstanceParent::GetImageContainer(ImageContainer** aContainer)

   691 {

   692 #ifdef XP_MACOSX

   693     MacIOSurface* ioSurface = nullptr;

   695     if (mFrontIOSurface) {

   696       ioSurface = mFrontIOSurface;

   697     } else if (mIOSurface) {

   698       ioSurface = mIOSurface;

   699     }

   701     if (!mFrontSurface && !ioSurface)

   702 #else

   703     if (!mFrontSurface)

   704 #endif

   705         return NS_ERROR_NOT_AVAILABLE;

   707     ImageContainer *container = GetImageContainer();

   709     if (!container) {

   710         return NS_ERROR_FAILURE;

   711     }

   713     if (IsAsyncDrawing()) {

   714       NS_IF_ADDREF(container);

   715       *aContainer = container;

   716       return NS_OK;

   717     }

   719 #ifdef XP_MACOSX

   720     if (ioSurface) {

   721         nsRefPtr<Image> image = container->CreateImage(ImageFormat::MAC_IOSURFACE);

   722         if (!image) {

   723             return NS_ERROR_FAILURE;

   724         }

   726         NS_ASSERTION(image->GetFormat() == ImageFormat::MAC_IOSURFACE, "Wrong format?");

   728         MacIOSurfaceImage* pluginImage = static_cast<MacIOSurfaceImage*>(image.get());

   729         pluginImage->SetSurface(ioSurface);

   731         container->SetCurrentImageInTransaction(pluginImage);

   733         NS_IF_ADDREF(container);

   734         *aContainer = container;

   735         return NS_OK;

   736     }

   737 #endif

   739     NS_IF_ADDREF(container);

   740     *aContainer = container;

   741     return NS_OK;

   742 }

   744 nsresult

   745 PluginInstanceParent::GetImageSize(nsIntSize* aSize)

   746 {

   747     if (mFrontSurface) {

   748         gfxIntSize size = mFrontSurface->GetSize();

   749         *aSize = nsIntSize(size.width, size.height);

   750         return NS_OK;

   751     }

   753 #ifdef XP_MACOSX

   754     if (mFrontIOSurface) {

   755         *aSize = nsIntSize(mFrontIOSurface->GetWidth(), mFrontIOSurface->GetHeight());

   756         return NS_OK;

   757     } else if (mIOSurface) {

   758         *aSize = nsIntSize(mIOSurface->GetWidth(), mIOSurface->GetHeight());

   759         return NS_OK;

   760     }

   761 #endif

   763     return NS_ERROR_NOT_AVAILABLE;

   764 }

   766 #ifdef XP_MACOSX

   767 nsresult

   768 PluginInstanceParent::IsRemoteDrawingCoreAnimation(bool *aDrawing)

   769 {

   770     *aDrawing = (NPDrawingModelCoreAnimation == (NPDrawingModel)mDrawingModel ||

   771                  NPDrawingModelInvalidatingCoreAnimation == (NPDrawingModel)mDrawingModel);

   772     return NS_OK;

   773 }

   775 nsresult

   776 PluginInstanceParent::ContentsScaleFactorChanged(double aContentsScaleFactor)

   777 {

   778     bool rv = SendContentsScaleFactorChanged(aContentsScaleFactor);

   779     return rv ? NS_OK : NS_ERROR_FAILURE;

   780 }

   781 #endif // #ifdef XP_MACOSX

   783 nsresult

   784 PluginInstanceParent::SetBackgroundUnknown()

   785 {

   786     PLUGIN_LOG_DEBUG(("[InstanceParent][%p] SetBackgroundUnknown", this));

   788     if (mBackground) {

   789         DestroyBackground();

   790         NS_ABORT_IF_FALSE(!mBackground, "Background not destroyed");

   791     }

   793     return NS_OK;

   794 }

   796 nsresult

   797 PluginInstanceParent::BeginUpdateBackground(const nsIntRect& aRect,

   798                                             gfxContext** aCtx)

   799 {

   800     PLUGIN_LOG_DEBUG(

   801         ("[InstanceParent][%p] BeginUpdateBackground for <x=%d,y=%d, w=%d,h=%d>",

   802          this, aRect.x, aRect.y, aRect.width, aRect.height));

   804     if (!mBackground) {

   805         // XXX if we failed to create a background surface on one

   806         // update, there's no guarantee that later updates will be for

   807         // the entire background area until successful.  We might want

   808         // to fix that eventually.

   809         NS_ABORT_IF_FALSE(aRect.TopLeft() == nsIntPoint(0, 0),

   810                           "Expecting rect for whole frame");

   811         if (!CreateBackground(aRect.Size())) {

   812             *aCtx = nullptr;

   813             return NS_OK;

   814         }

   815     }

   817     gfxIntSize sz = mBackground->GetSize();

   818 #ifdef DEBUG

   819     NS_ABORT_IF_FALSE(nsIntRect(0, 0, sz.width, sz.height).Contains(aRect),

   820                       "Update outside of background area");

   821 #endif

   823     RefPtr<gfx::DrawTarget> dt = gfxPlatform::GetPlatform()->

   824       CreateDrawTargetForSurface(mBackground, gfx::IntSize(sz.width, sz.height));

   825     nsRefPtr<gfxContext> ctx = new gfxContext(dt);

   826     ctx.forget(aCtx);

   828     return NS_OK;

   829 }

   831 nsresult

   832 PluginInstanceParent::EndUpdateBackground(gfxContext* aCtx,

   833                                           const nsIntRect& aRect)

   834 {

   835     PLUGIN_LOG_DEBUG(

   836         ("[InstanceParent][%p] EndUpdateBackground for <x=%d,y=%d, w=%d,h=%d>",

   837          this, aRect.x, aRect.y, aRect.width, aRect.height));

   839 #ifdef MOZ_X11

   840     // Have to XSync here to avoid the plugin trying to draw with this

   841     // surface racing with its creation in the X server.  We also want

   842     // to avoid the plugin drawing onto stale pixels, then handing us

   843     // back a front surface from those pixels that we might

   844     // recomposite for "a while" until the next update.  This XSync

   845     // still doesn't guarantee that the plugin draws onto a consistent

   846     // view of its background, but it does mean that the plugin is

   847     // drawing onto pixels no older than those in the latest

   848     // EndUpdateBackground().

   849     XSync(DefaultXDisplay(), False);

   850 #endif

   852     unused << SendUpdateBackground(BackgroundDescriptor(), aRect);

   854     return NS_OK;

   855 }

   857 bool

   858 PluginInstanceParent::CreateBackground(const nsIntSize& aSize)

   859 {

   860     NS_ABORT_IF_FALSE(!mBackground, "Already have a background");

   862     // XXX refactor me

   864 #if defined(MOZ_X11)

   865     Screen* screen = DefaultScreenOfDisplay(DefaultXDisplay());

   866     Visual* visual = DefaultVisualOfScreen(screen);

   867     mBackground = gfxXlibSurface::Create(screen, visual,

   868                                          gfxIntSize(aSize.width, aSize.height));

   869     return !!mBackground;

   871 #elif defined(XP_WIN)

   872     // We have chosen to create an unsafe surface in which the plugin

   873     // can read from the region while we're writing to it.

   874     mBackground =

   875         gfxSharedImageSurface::CreateUnsafe(

   876             this,

   877             gfxIntSize(aSize.width, aSize.height),

   878             gfxImageFormat::RGB24);

   879     return !!mBackground;

   880 #else

   881     return nullptr;

   882 #endif

   883 }

   885 void

   886 PluginInstanceParent::DestroyBackground()

   887 {

   888     if (!mBackground) {

   889         return;

   890     }

   892     // Relinquish ownership of |mBackground| to its destroyer

   893     PPluginBackgroundDestroyerParent* pbd =

   894         new PluginBackgroundDestroyerParent(mBackground);

   895     mBackground = nullptr;

   897     // If this fails, there's no problem: |bd| will be destroyed along

   898     // with the old background surface.

   899     unused << SendPPluginBackgroundDestroyerConstructor(pbd);

   900 }

   902 mozilla::plugins::SurfaceDescriptor

   903 PluginInstanceParent::BackgroundDescriptor()

   904 {

   905     NS_ABORT_IF_FALSE(mBackground, "Need a background here");

   907     // XXX refactor me

   909 #ifdef MOZ_X11

   910     gfxXlibSurface* xsurf = static_cast<gfxXlibSurface*>(mBackground.get());

   911     return SurfaceDescriptorX11(xsurf);

   912 #endif

   914 #ifdef XP_WIN

   915     NS_ABORT_IF_FALSE(gfxSharedImageSurface::IsSharedImage(mBackground),

   916                       "Expected shared image surface");

   917     gfxSharedImageSurface* shmem =

   918         static_cast<gfxSharedImageSurface*>(mBackground.get());

   919     return shmem->GetShmem();

   920 #endif

   922     // If this is ever used, which it shouldn't be, it will trigger a

   923     // hard assertion in IPDL-generated code.

   924     return mozilla::plugins::SurfaceDescriptor();

   925 }

   927 ImageContainer*

   928 PluginInstanceParent::GetImageContainer()

   929 {

   930   if (mImageContainer) {

   931     return mImageContainer;

   932   }

   934   mImageContainer = LayerManager::CreateImageContainer();

   935   return mImageContainer;

   936 }

   938 PPluginBackgroundDestroyerParent*

   939 PluginInstanceParent::AllocPPluginBackgroundDestroyerParent()

   940 {

   941     NS_RUNTIMEABORT("'Power-user' ctor is used exclusively");

   942     return nullptr;

   943 }

   945 bool

   946 PluginInstanceParent::DeallocPPluginBackgroundDestroyerParent(

   947     PPluginBackgroundDestroyerParent* aActor)

   948 {

   949     delete aActor;

   950     return true;

   951 }

   953 NPError

   954 PluginInstanceParent::NPP_SetWindow(const NPWindow* aWindow)

   955 {

   956     PLUGIN_LOG_DEBUG(("%s (aWindow=%p)", FULLFUNCTION, (void*) aWindow));

   958     NS_ENSURE_TRUE(aWindow, NPERR_GENERIC_ERROR);

   960     NPRemoteWindow window;

   961     mWindowType = aWindow->type;

   963 #if defined(OS_WIN)

   964     // On windowless controls, reset the shared memory surface as needed.

   965     if (mWindowType == NPWindowTypeDrawable) {

   966         // SharedSurfaceSetWindow will take care of NPRemoteWindow.

   967         if (!SharedSurfaceSetWindow(aWindow, window)) {

   968           return NPERR_OUT_OF_MEMORY_ERROR;

   969         }

   970     }

   971     else {

   972         SubclassPluginWindow(reinterpret_cast<HWND>(aWindow->window));

   974         window.window = reinterpret_cast<uint64_t>(aWindow->window);

   975         window.x = aWindow->x;

   976         window.y = aWindow->y;

   977         window.width = aWindow->width;

   978         window.height = aWindow->height;

   979         window.type = aWindow->type;

   980     }

   981 #else

   982     window.window = reinterpret_cast<uint64_t>(aWindow->window);

   983     window.x = aWindow->x;

   984     window.y = aWindow->y;

   985     window.width = aWindow->width;

   986     window.height = aWindow->height;

   987     window.clipRect = aWindow->clipRect; // MacOS specific

   988     window.type = aWindow->type;

   989 #endif

   991 #if defined(XP_MACOSX)

   992     double floatScaleFactor = 1.0;

   993     mNPNIface->getvalue(mNPP, NPNVcontentsScaleFactor, &floatScaleFactor);

   994     int scaleFactor = ceil(floatScaleFactor);

   995     window.contentsScaleFactor = floatScaleFactor;

   997     if (mShWidth != window.width * scaleFactor || mShHeight != window.height * scaleFactor) {

   998         if (mDrawingModel == NPDrawingModelCoreAnimation ||

   999             mDrawingModel == NPDrawingModelInvalidatingCoreAnimation) {

  1000             mIOSurface = MacIOSurface::CreateIOSurface(window.width, window.height,

  1001                                                        floatScaleFactor);

  1002         } else if (uint32_t(mShWidth * mShHeight) !=

  1003                    window.width * scaleFactor * window.height * scaleFactor) {

  1004             if (mShWidth != 0 && mShHeight != 0) {

  1005                 DeallocShmem(mShSurface);

  1006                 mShWidth = 0;

  1007                 mShHeight = 0;

  1008             }

  1010             if (window.width != 0 && window.height != 0) {

  1011                 if (!AllocShmem(window.width * scaleFactor * window.height*4 * scaleFactor,

  1012                                 SharedMemory::TYPE_BASIC, &mShSurface)) {

  1013                     PLUGIN_LOG_DEBUG(("Shared memory could not be allocated."));

  1014                     return NPERR_GENERIC_ERROR;

  1015                 }

  1016             }

  1017         }

  1018         mShWidth = window.width * scaleFactor;

  1019         mShHeight = window.height * scaleFactor;

  1020     }

  1021 #endif

  1023 #if defined(MOZ_X11) && defined(XP_UNIX) && !defined(XP_MACOSX)

  1024     const NPSetWindowCallbackStruct* ws_info =

  1025       static_cast<NPSetWindowCallbackStruct*>(aWindow->ws_info);

  1026     window.visualID = ws_info->visual ? ws_info->visual->visualid : None;

  1027     window.colormap = ws_info->colormap;

  1028 #endif

  1030     if (!CallNPP_SetWindow(window))

  1031         return NPERR_GENERIC_ERROR;

  1033     return NPERR_NO_ERROR;

  1034 }

  1036 NPError

  1037 PluginInstanceParent::NPP_GetValue(NPPVariable aVariable,

  1038                                    void* _retval)

  1039 {

  1040     switch (aVariable) {

  1042     case NPPVpluginWantsAllNetworkStreams: {

  1043         bool wantsAllStreams;

  1044         NPError rv;

  1046         if (!CallNPP_GetValue_NPPVpluginWantsAllNetworkStreams(&wantsAllStreams, &rv)) {

  1047             return NPERR_GENERIC_ERROR;

  1048         }

  1050         if (NPERR_NO_ERROR != rv) {

  1051             return rv;

  1052         }

  1054         (*(NPBool*)_retval) = wantsAllStreams;

  1055         return NPERR_NO_ERROR;

  1056     }

  1058 #ifdef MOZ_X11

  1059     case NPPVpluginNeedsXEmbed: {

  1060         bool needsXEmbed;

  1061         NPError rv;

  1063         if (!CallNPP_GetValue_NPPVpluginNeedsXEmbed(&needsXEmbed, &rv)) {

  1064             return NPERR_GENERIC_ERROR;

  1065         }

  1067         if (NPERR_NO_ERROR != rv) {

  1068             return rv;

  1069         }

  1071         (*(NPBool*)_retval) = needsXEmbed;

  1072         return NPERR_NO_ERROR;

  1073     }

  1074 #endif

  1076     case NPPVpluginScriptableNPObject: {

  1077         PPluginScriptableObjectParent* actor;

  1078         NPError rv;

  1079         if (!CallNPP_GetValue_NPPVpluginScriptableNPObject(&actor, &rv)) {

  1080             return NPERR_GENERIC_ERROR;

  1081         }

  1083         if (NPERR_NO_ERROR != rv) {

  1084             return rv;

  1085         }

  1087         if (!actor) {

  1088             NS_ERROR("NPPVpluginScriptableNPObject succeeded but null.");

  1089             return NPERR_GENERIC_ERROR;

  1090         }

  1092         const NPNetscapeFuncs* npn = mParent->GetNetscapeFuncs();

  1093         if (!npn) {

  1094             NS_WARNING("No netscape functions?!");

  1095             return NPERR_GENERIC_ERROR;

  1096         }

  1098         NPObject* object =

  1099             static_cast<PluginScriptableObjectParent*>(actor)->GetObject(true);

  1100         NS_ASSERTION(object, "This shouldn't ever be null!");

  1102         (*(NPObject**)_retval) = npn->retainobject(object);

  1103         return NPERR_NO_ERROR;

  1104     }

  1106 #ifdef MOZ_ACCESSIBILITY_ATK

  1107     case NPPVpluginNativeAccessibleAtkPlugId: {

  1108         nsCString plugId;

  1109         NPError rv;

  1110         if (!CallNPP_GetValue_NPPVpluginNativeAccessibleAtkPlugId(&plugId, &rv)) {

  1111             return NPERR_GENERIC_ERROR;

  1112         }

  1114         if (NPERR_NO_ERROR != rv) {

  1115             return rv;

  1116         }

  1118         (*(nsCString*)_retval) = plugId;

  1119         return NPERR_NO_ERROR;

  1120     }

  1121 #endif

  1123     default:

  1124         PR_LOG(GetPluginLog(), PR_LOG_WARNING,

  1125                ("In PluginInstanceParent::NPP_GetValue: Unhandled NPPVariable %i (%s)",

  1126                 (int) aVariable, NPPVariableToString(aVariable)));

  1127         return NPERR_GENERIC_ERROR;

  1128     }

  1129 }

  1131 NPError

  1132 PluginInstanceParent::NPP_SetValue(NPNVariable variable, void* value)

  1133 {

  1134     switch (variable) {

  1135     case NPNVprivateModeBool:

  1136         NPError result;

  1137         if (!CallNPP_SetValue_NPNVprivateModeBool(*static_cast<NPBool*>(value),

  1138                                                   &result))

  1139             return NPERR_GENERIC_ERROR;

  1141         return result;

  1143     default:

  1144         NS_ERROR("Unhandled NPNVariable in NPP_SetValue");

  1145         PR_LOG(GetPluginLog(), PR_LOG_WARNING,

  1146                ("In PluginInstanceParent::NPP_SetValue: Unhandled NPNVariable %i (%s)",

  1147                 (int) variable, NPNVariableToString(variable)));

  1148         return NPERR_GENERIC_ERROR;

  1149     }

  1150 }

  1152 void

  1153 PluginInstanceParent::NPP_URLRedirectNotify(const char* url, int32_t status,

  1154                                             void* notifyData)

  1155 {

  1156   if (!notifyData)

  1157     return;

  1159   PStreamNotifyParent* streamNotify = static_cast<PStreamNotifyParent*>(notifyData);

  1160   unused << streamNotify->SendRedirectNotify(NullableString(url), status);

  1161 }

  1163 int16_t

  1164 PluginInstanceParent::NPP_HandleEvent(void* event)

  1165 {

  1166     PLUGIN_LOG_DEBUG_FUNCTION;

  1168 #if defined(XP_MACOSX)

  1169     NPCocoaEvent* npevent = reinterpret_cast<NPCocoaEvent*>(event);

  1170 #else

  1171     NPEvent* npevent = reinterpret_cast<NPEvent*>(event);

  1172 #endif

  1173     NPRemoteEvent npremoteevent;

  1174     npremoteevent.event = *npevent;

  1175 #if defined(XP_MACOSX)

  1176     double scaleFactor = 1.0;

  1177     mNPNIface->getvalue(mNPP, NPNVcontentsScaleFactor, &scaleFactor);

  1178     npremoteevent.contentsScaleFactor = scaleFactor;

  1179 #endif

  1180     int16_t handled = 0;

  1182 #if defined(OS_WIN)

  1183     if (mWindowType == NPWindowTypeDrawable) {

  1184         if (IsAsyncDrawing()) {

  1185             if (npevent->event == WM_PAINT || npevent->event == DoublePassRenderingEvent()) {

  1186                 // This plugin maintains its own async drawing.

  1187                 return handled;

  1188             }

  1189         }

  1190         if (DoublePassRenderingEvent() == npevent->event) {

  1191             return CallPaint(npremoteevent, &handled) && handled;

  1192         }

  1194         switch (npevent->event) {

  1195             case WM_PAINT:

  1196             {

  1197                 RECT rect;

  1198                 SharedSurfaceBeforePaint(rect, npremoteevent);

  1199                 if (!CallPaint(npremoteevent, &handled)) {

  1200                     handled = false;

  1201                 }

  1202                 SharedSurfaceAfterPaint(npevent);

  1203                 return handled;

  1204             }

  1205             break;

  1207             case WM_KILLFOCUS:

  1208             {

  1209               // When the user selects fullscreen mode in Flash video players,

  1210               // WM_KILLFOCUS will be delayed by deferred event processing:

  1211               // WM_LBUTTONUP results in a call to CreateWindow within Flash,

  1212               // which fires WM_KILLFOCUS. Delayed delivery causes Flash to

  1213               // misinterpret the event, dropping back out of fullscreen. Trap

  1214               // this event and drop it.

  1215               wchar_t szClass[26];

  1216               HWND hwnd = GetForegroundWindow();

  1217               if (hwnd && hwnd != mPluginHWND &&

  1218                   GetClassNameW(hwnd, szClass,

  1219                                 sizeof(szClass)/sizeof(char16_t)) &&

  1220                   !wcscmp(szClass, kFlashFullscreenClass)) {

  1221                   return 0;

  1222               }

  1223             }

  1224             break;

  1226             case WM_WINDOWPOSCHANGED:

  1227             {

  1228                 // We send this in nsObjectFrame just before painting

  1229                 return SendWindowPosChanged(npremoteevent);

  1230             }

  1231             break;

  1232         }

  1233     }

  1234 #endif

  1236 #if defined(MOZ_X11)

  1237     switch (npevent->type) {

  1238     case GraphicsExpose:

  1239         PLUGIN_LOG_DEBUG(("  schlepping drawable 0x%lx across the pipe\n",

  1240                           npevent->xgraphicsexpose.drawable));

  1241         // Make sure the X server has created the Drawable and completes any

  1242         // drawing before the plugin draws on top.

  1243         //

  1244         // XSync() waits for the X server to complete.  Really this parent

  1245         // process does not need to wait; the child is the process that needs

  1246         // to wait.  A possibly-slightly-better alternative would be to send

  1247         // an X event to the child that the child would wait for.

  1248         FinishX(DefaultXDisplay());

  1250         return CallPaint(npremoteevent, &handled) ? handled : 0;

  1252     case ButtonPress:

  1253         // Release any active pointer grab so that the plugin X client can

  1254         // grab the pointer if it wishes.

  1255         Display *dpy = DefaultXDisplay();

  1256 #  ifdef MOZ_WIDGET_GTK

  1257         // GDK attempts to (asynchronously) track whether there is an active

  1258         // grab so ungrab through GDK.

  1259         gdk_pointer_ungrab(npevent->xbutton.time);

  1260 #  else

  1261         XUngrabPointer(dpy, npevent->xbutton.time);

  1262 #  endif

  1263         // Wait for the ungrab to complete.

  1264         XSync(dpy, False);

  1265         break;

  1266     }

  1267 #endif

  1269 #ifdef XP_MACOSX

  1270     if (npevent->type == NPCocoaEventDrawRect) {

  1271         if (mDrawingModel == NPDrawingModelCoreAnimation ||

  1272             mDrawingModel == NPDrawingModelInvalidatingCoreAnimation) {

  1273             if (!mIOSurface) {

  1274                 NS_ERROR("No IOSurface allocated.");

  1275                 return false;

  1276             }

  1277             if (!CallNPP_HandleEvent_IOSurface(npremoteevent,

  1278                                                mIOSurface->GetIOSurfaceID(),

  1279                                                &handled))

  1280                 return false; // no good way to handle errors here...

  1282             CGContextRef cgContext = npevent->data.draw.context;

  1283             if (!mShColorSpace) {

  1284                 mShColorSpace = CreateSystemColorSpace();

  1285             }

  1286             if (!mShColorSpace) {

  1287                 PLUGIN_LOG_DEBUG(("Could not allocate ColorSpace."));

  1288                 return false;

  1289             }

  1290             if (cgContext) {

  1291                 nsCARenderer::DrawSurfaceToCGContext(cgContext, mIOSurface,

  1292                                                      mShColorSpace,

  1293                                                      npevent->data.draw.x,

  1294                                                      npevent->data.draw.y,

  1295                                                      npevent->data.draw.width,

  1296                                                      npevent->data.draw.height);

  1297             }

  1298             return true;

  1299         } else if (mFrontIOSurface) {

  1300             CGContextRef cgContext = npevent->data.draw.context;

  1301             if (!mShColorSpace) {

  1302                 mShColorSpace = CreateSystemColorSpace();

  1303             }

  1304             if (!mShColorSpace) {

  1305                 PLUGIN_LOG_DEBUG(("Could not allocate ColorSpace."));

  1306                 return false;

  1307             }

  1308             if (cgContext) {

  1309                 nsCARenderer::DrawSurfaceToCGContext(cgContext, mFrontIOSurface,

  1310                                                      mShColorSpace,

  1311                                                      npevent->data.draw.x,

  1312                                                      npevent->data.draw.y,

  1313                                                      npevent->data.draw.width,

  1314                                                      npevent->data.draw.height);

  1315             }

  1316             return true;

  1317         } else {

  1318             if (mShWidth == 0 && mShHeight == 0) {

  1319                 PLUGIN_LOG_DEBUG(("NPCocoaEventDrawRect on window of size 0."));

  1320                 return false;

  1321             }

  1322             if (!mShSurface.IsReadable()) {

  1323                 PLUGIN_LOG_DEBUG(("Shmem is not readable."));

  1324                 return false;

  1325             }

  1327             if (!CallNPP_HandleEvent_Shmem(npremoteevent, mShSurface,

  1328                                            &handled, &mShSurface))

  1329                 return false; // no good way to handle errors here...

  1331             if (!mShSurface.IsReadable()) {

  1332                 PLUGIN_LOG_DEBUG(("Shmem not returned. Either the plugin crashed "

  1333                                   "or we have a bug."));

  1334                 return false;

  1335             }

  1337             char* shContextByte = mShSurface.get<char>();

  1339             if (!mShColorSpace) {

  1340                 mShColorSpace = CreateSystemColorSpace();

  1341             }

  1342             if (!mShColorSpace) {

  1343                 PLUGIN_LOG_DEBUG(("Could not allocate ColorSpace."));

  1344                 return false;

  1345             }

  1346             CGContextRef shContext = ::CGBitmapContextCreate(shContextByte,

  1347                                     mShWidth, mShHeight, 8,

  1348                                     mShWidth*4, mShColorSpace,

  1349                                     kCGImageAlphaPremultipliedFirst |

  1350                                     kCGBitmapByteOrder32Host);

  1351             if (!shContext) {

  1352                 PLUGIN_LOG_DEBUG(("Could not allocate CGBitmapContext."));

  1353                 return false;

  1354             }

  1356             CGImageRef shImage = ::CGBitmapContextCreateImage(shContext);

  1357             if (shImage) {

  1358                 CGContextRef cgContext = npevent->data.draw.context;

  1360                 ::CGContextDrawImage(cgContext,

  1361                                      CGRectMake(0,0,mShWidth,mShHeight),

  1362                                      shImage);

  1363                 ::CGImageRelease(shImage);

  1364             } else {

  1365                 ::CGContextRelease(shContext);

  1366                 return false;

  1367             }

  1368             ::CGContextRelease(shContext);

  1369             return true;

  1370         }

  1371     }

  1372 #endif

  1374     if (!CallNPP_HandleEvent(npremoteevent, &handled))

  1375         return 0; // no good way to handle errors here...

  1377     return handled;

  1378 }

  1380 NPError

  1381 PluginInstanceParent::NPP_NewStream(NPMIMEType type, NPStream* stream,

  1382                                     NPBool seekable, uint16_t* stype)

  1383 {

  1384     PLUGIN_LOG_DEBUG(("%s (type=%s, stream=%p, seekable=%i)",

  1385                       FULLFUNCTION, (char*) type, (void*) stream, (int) seekable));

  1387     BrowserStreamParent* bs = new BrowserStreamParent(this, stream);

  1389     NPError err;

  1390     if (!CallPBrowserStreamConstructor(bs,

  1391                                        NullableString(stream->url),

  1392                                        stream->end,

  1393                                        stream->lastmodified,

  1394                                        static_cast<PStreamNotifyParent*>(stream->notifyData),

  1395                                        NullableString(stream->headers),

  1396                                        NullableString(type), seekable,

  1397                                        &err, stype))

  1398         return NPERR_GENERIC_ERROR;

  1400     if (NPERR_NO_ERROR != err)

  1401         unused << PBrowserStreamParent::Send__delete__(bs);

  1403     return err;

  1404 }

  1406 NPError

  1407 PluginInstanceParent::NPP_DestroyStream(NPStream* stream, NPReason reason)

  1408 {

  1409     PLUGIN_LOG_DEBUG(("%s (stream=%p, reason=%i)",

  1410                       FULLFUNCTION, (void*) stream, (int) reason));

  1412     AStream* s = static_cast<AStream*>(stream->pdata);

  1413     if (s->IsBrowserStream()) {

  1414         BrowserStreamParent* sp =

  1415             static_cast<BrowserStreamParent*>(s);

  1416         if (sp->mNPP != this)

  1417             NS_RUNTIMEABORT("Mismatched plugin data");

  1419         sp->NPP_DestroyStream(reason);

  1420         return NPERR_NO_ERROR;

  1421     }

  1422     else {

  1423         PluginStreamParent* sp =

  1424             static_cast<PluginStreamParent*>(s);

  1425         if (sp->mInstance != this)

  1426             NS_RUNTIMEABORT("Mismatched plugin data");

  1428         return PPluginStreamParent::Call__delete__(sp, reason, false) ?

  1429             NPERR_NO_ERROR : NPERR_GENERIC_ERROR;

  1430     }

  1431 }

  1433 void

  1434 PluginInstanceParent::NPP_Print(NPPrint* platformPrint)

  1435 {

  1436     // TODO: implement me

  1437     NS_ERROR("Not implemented");

  1438 }

  1440 PPluginScriptableObjectParent*

  1441 PluginInstanceParent::AllocPPluginScriptableObjectParent()

  1442 {

  1443     return new PluginScriptableObjectParent(Proxy);

  1444 }

  1446 #ifdef DEBUG

  1447 namespace {

  1449 struct ActorSearchData

  1450 {

  1451     PluginScriptableObjectParent* actor;

  1452     bool found;

  1453 };

  1455 PLDHashOperator

  1456 ActorSearch(NPObject* aKey,

  1457             PluginScriptableObjectParent* aData,

  1458             void* aUserData)

  1459 {

  1460     ActorSearchData* asd = reinterpret_cast<ActorSearchData*>(aUserData);

  1461     if (asd->actor == aData) {

  1462         asd->found = true;

  1463         return PL_DHASH_STOP;

  1464     }

  1465     return PL_DHASH_NEXT;

  1466 }

  1468 } // anonymous namespace

  1469 #endif // DEBUG

  1471 bool

  1472 PluginInstanceParent::DeallocPPluginScriptableObjectParent(

  1473                                          PPluginScriptableObjectParent* aObject)

  1474 {

  1475     PluginScriptableObjectParent* actor =

  1476         static_cast<PluginScriptableObjectParent*>(aObject);

  1478     NPObject* object = actor->GetObject(false);

  1479     if (object) {

  1480         NS_ASSERTION(mScriptableObjects.Get(object, nullptr),

  1481                      "NPObject not in the hash!");

  1482         mScriptableObjects.Remove(object);

  1483     }

  1484 #ifdef DEBUG

  1485     else {

  1486         ActorSearchData asd = { actor, false };

  1487         mScriptableObjects.EnumerateRead(ActorSearch, &asd);

  1488         NS_ASSERTION(!asd.found, "Actor in the hash with a null NPObject!");

  1489     }

  1490 #endif

  1492     delete actor;

  1493     return true;

  1494 }

  1496 bool

  1497 PluginInstanceParent::RecvPPluginScriptableObjectConstructor(

  1498                                           PPluginScriptableObjectParent* aActor)

  1499 {

  1500     // This is only called in response to the child process requesting the

  1501     // creation of an actor. This actor will represent an NPObject that is

  1502     // created by the plugin and returned to the browser.

  1503     PluginScriptableObjectParent* actor =

  1504         static_cast<PluginScriptableObjectParent*>(aActor);

  1505     NS_ASSERTION(!actor->GetObject(false), "Actor already has an object?!");

  1507     actor->InitializeProxy();

  1508     NS_ASSERTION(actor->GetObject(false), "Actor should have an object!");

  1510     return true;

  1511 }

  1513 void

  1514 PluginInstanceParent::NPP_URLNotify(const char* url, NPReason reason,

  1515                                     void* notifyData)

  1516 {

  1517     PLUGIN_LOG_DEBUG(("%s (%s, %i, %p)",

  1518                       FULLFUNCTION, url, (int) reason, notifyData));

  1520     PStreamNotifyParent* streamNotify =

  1521         static_cast<PStreamNotifyParent*>(notifyData);

  1522     unused << PStreamNotifyParent::Send__delete__(streamNotify, reason);

  1523 }

  1525 bool

  1526 PluginInstanceParent::RegisterNPObjectForActor(

  1527                                            NPObject* aObject,

  1528                                            PluginScriptableObjectParent* aActor)

  1529 {

  1530     NS_ASSERTION(aObject && aActor, "Null pointers!");

  1531     NS_ASSERTION(!mScriptableObjects.Get(aObject, nullptr), "Duplicate entry!");

  1532     mScriptableObjects.Put(aObject, aActor);

  1533     return true;

  1534 }

  1536 void

  1537 PluginInstanceParent::UnregisterNPObject(NPObject* aObject)

  1538 {

  1539     NS_ASSERTION(aObject, "Null pointer!");

  1540     NS_ASSERTION(mScriptableObjects.Get(aObject, nullptr), "Unknown entry!");

  1541     mScriptableObjects.Remove(aObject);

  1542 }

  1544 PluginScriptableObjectParent*

  1545 PluginInstanceParent::GetActorForNPObject(NPObject* aObject)

  1546 {

  1547     NS_ASSERTION(aObject, "Null pointer!");

  1549     if (aObject->_class == PluginScriptableObjectParent::GetClass()) {

  1550         // One of ours!

  1551         ParentNPObject* object = static_cast<ParentNPObject*>(aObject);

  1552         NS_ASSERTION(object->parent, "Null actor!");

  1553         return object->parent;

  1554     }

  1556     PluginScriptableObjectParent* actor;

  1557     if (mScriptableObjects.Get(aObject, &actor)) {

  1558         return actor;

  1559     }

  1561     actor = new PluginScriptableObjectParent(LocalObject);

  1562     if (!actor) {

  1563         NS_ERROR("Out of memory!");

  1564         return nullptr;

  1565     }

  1567     if (!SendPPluginScriptableObjectConstructor(actor)) {

  1568         NS_WARNING("Failed to send constructor message!");

  1569         return nullptr;

  1570     }

  1572     actor->InitializeLocal(aObject);

  1573     return actor;

  1574 }

  1576 PPluginSurfaceParent*

  1577 PluginInstanceParent::AllocPPluginSurfaceParent(const WindowsSharedMemoryHandle& handle,

  1578                                                 const gfxIntSize& size,

  1579                                                 const bool& transparent)

  1580 {

  1581 #ifdef XP_WIN

  1582     return new PluginSurfaceParent(handle, size, transparent);

  1583 #else

  1584     NS_ERROR("This shouldn't be called!");

  1585     return nullptr;

  1586 #endif

  1587 }

  1589 bool

  1590 PluginInstanceParent::DeallocPPluginSurfaceParent(PPluginSurfaceParent* s)

  1591 {

  1592 #ifdef XP_WIN

  1593     delete s;

  1594     return true;

  1595 #else

  1596     return false;

  1597 #endif

  1598 }

  1600 bool

  1601 PluginInstanceParent::AnswerNPN_PushPopupsEnabledState(const bool& aState)

  1602 {

  1603     mNPNIface->pushpopupsenabledstate(mNPP, aState ? 1 : 0);

  1604     return true;

  1605 }

  1607 bool

  1608 PluginInstanceParent::AnswerNPN_PopPopupsEnabledState()

  1609 {

  1610     mNPNIface->poppopupsenabledstate(mNPP);

  1611     return true;

  1612 }

  1614 bool

  1615 PluginInstanceParent::AnswerNPN_GetValueForURL(const NPNURLVariable& variable,

  1616                                                const nsCString& url,

  1617                                                nsCString* value,

  1618                                                NPError* result)

  1619 {

  1620     char* v;

  1621     uint32_t len;

  1623     *result = mNPNIface->getvalueforurl(mNPP, (NPNURLVariable) variable,

  1624                                         url.get(), &v, &len);

  1625     if (NPERR_NO_ERROR == *result)

  1626         value->Adopt(v, len);

  1628     return true;

  1629 }

  1631 bool

  1632 PluginInstanceParent::AnswerNPN_SetValueForURL(const NPNURLVariable& variable,

  1633                                                const nsCString& url,

  1634                                                const nsCString& value,

  1635                                                NPError* result)

  1636 {

  1637     *result = mNPNIface->setvalueforurl(mNPP, (NPNURLVariable) variable,

  1638                                         url.get(), value.get(),

  1639                                         value.Length());

  1640     return true;

  1641 }

  1643 bool

  1644 PluginInstanceParent::AnswerNPN_GetAuthenticationInfo(const nsCString& protocol,

  1645                                                       const nsCString& host,

  1646                                                       const int32_t& port,

  1647                                                       const nsCString& scheme,

  1648                                                       const nsCString& realm,

  1649                                                       nsCString* username,

  1650                                                       nsCString* password,

  1651                                                       NPError* result)

  1652 {

  1653     char* u;

  1654     uint32_t ulen;

  1655     char* p;

  1656     uint32_t plen;

  1658     *result = mNPNIface->getauthenticationinfo(mNPP, protocol.get(),

  1659                                                host.get(), port,

  1660                                                scheme.get(), realm.get(),

  1661                                                &u, &ulen, &p, &plen);

  1662     if (NPERR_NO_ERROR == *result) {

  1663         username->Adopt(u, ulen);

  1664         password->Adopt(p, plen);

  1665     }

  1666     return true;

  1667 }

  1669 bool

  1670 PluginInstanceParent::AnswerNPN_ConvertPoint(const double& sourceX,

  1671                                              const bool&   ignoreDestX,

  1672                                              const double& sourceY,

  1673                                              const bool&   ignoreDestY,

  1674                                              const NPCoordinateSpace& sourceSpace,

  1675                                              const NPCoordinateSpace& destSpace,

  1676                                              double *destX,

  1677                                              double *destY,

  1678                                              bool *result)

  1679 {

  1680     *result = mNPNIface->convertpoint(mNPP, sourceX, sourceY, sourceSpace,

  1681                                       ignoreDestX ? nullptr : destX,

  1682                                       ignoreDestY ? nullptr : destY,

  1683                                       destSpace);

  1685     return true;

  1686 }

  1688 bool

  1689 PluginInstanceParent::AnswerNPN_InitAsyncSurface(const gfxIntSize& size,

  1690                                                  const NPImageFormat& format,

  1691                                                  NPRemoteAsyncSurface* surfData,

  1692                                                  bool* result)

  1693 {

  1694     if (!IsAsyncDrawing()) {

  1695         *result = false;

  1696         return true;

  1697     }

  1699     switch (mDrawingModel) {

  1700     case NPDrawingModelAsyncBitmapSurface: {

  1701             Shmem sharedMem;

  1702             if (!AllocUnsafeShmem(size.width * size.height * 4, SharedMemory::TYPE_BASIC, &sharedMem)) {

  1703                 *result = false;

  1704                 return true;

  1705             }

  1707             surfData->size() = size;

  1708             surfData->hostPtr() = (uintptr_t)sharedMem.get<unsigned char>();

  1709             surfData->stride() = size.width * 4;

  1710             surfData->format() = format;

  1711             surfData->data() = sharedMem;

  1712             *result = true;

  1713             return true;

  1714         }

  1715 #ifdef XP_WIN

  1716     case NPDrawingModelAsyncWindowsDXGISurface: {

  1717             ID3D10Device1 *device = gfxWindowsPlatform::GetPlatform()->GetD3D10Device();

  1719             nsRefPtr<ID3D10Texture2D> texture;

  1721             CD3D10_TEXTURE2D_DESC desc(DXGI_FORMAT_B8G8R8A8_UNORM, size.width, size.height, 1, 1);

  1722             desc.MiscFlags = D3D10_RESOURCE_MISC_SHARED_KEYEDMUTEX;

  1723             desc.BindFlags = D3D10_BIND_RENDER_TARGET | D3D10_BIND_SHADER_RESOURCE;

  1724             if (FAILED(device->CreateTexture2D(&desc, nullptr, getter_AddRefs(texture)))) {

  1725                 *result = false;

  1726                 return true;

  1727             }

  1729             nsRefPtr<IDXGIResource> resource;

  1730             if (FAILED(texture->QueryInterface(IID_IDXGIResource, getter_AddRefs(resource)))) {

  1731                 *result = false;

  1732                 return true;

  1733             }

  1735             HANDLE sharedHandle;

  1737             if (FAILED(resource->GetSharedHandle(&sharedHandle))) {

  1738                 *result = false;

  1739                 return true;

  1740             }

  1742             surfData->size() = size;

  1743             surfData->data() = sharedHandle;

  1744             surfData->format() = format;

  1746             mTextureMap.Put(sharedHandle, texture);

  1747             *result = true;

  1748         }

  1749 #endif

  1750     }

  1752     return true;

  1753 }

  1755 bool

  1756 PluginInstanceParent::RecvRedrawPlugin()

  1757 {

  1758     nsNPAPIPluginInstance *inst = static_cast<nsNPAPIPluginInstance*>(mNPP->ndata);

  1759     if (!inst) {

  1760         return false;

  1761     }

  1763     inst->RedrawPlugin();

  1764     return true;

  1765 }

  1767 bool

  1768 PluginInstanceParent::RecvNegotiatedCarbon()

  1769 {

  1770     nsNPAPIPluginInstance *inst = static_cast<nsNPAPIPluginInstance*>(mNPP->ndata);

  1771     if (!inst) {

  1772         return false;

  1773     }

  1774     inst->CarbonNPAPIFailure();

  1775     return true;

  1776 }

  1778 bool

  1779 PluginInstanceParent::RecvReleaseDXGISharedSurface(const DXGISharedSurfaceHandle &aHandle)

  1780 {

  1781 #ifdef XP_WIN

  1782     mTextureMap.Remove(aHandle);

  1783 #endif

  1784     return true;

  1785 }

  1787 #if defined(OS_WIN)

  1789 /*

  1790   plugin focus changes between processes

  1792   focus from dom -> child:

  1793     Focus manager calls on widget to set the focus on the window.

  1794     We pick up the resulting wm_setfocus event here, and forward

  1795     that over ipc to the child which calls set focus on itself.

  1797   focus from child -> focus manager:

  1798     Child picks up the local wm_setfocus and sends it via ipc over

  1799     here. We then post a custom event to widget/windows/nswindow

  1800     which fires off a gui event letting the browser know.

  1801 */

  1803 static const wchar_t kPluginInstanceParentProperty[] =

  1804                          L"PluginInstanceParentProperty";

  1806 // static

  1807 LRESULT CALLBACK

  1808 PluginInstanceParent::PluginWindowHookProc(HWND hWnd,

  1809                                            UINT message,

  1810                                            WPARAM wParam,

  1811                                            LPARAM lParam)

  1812 {

  1813     PluginInstanceParent* self = reinterpret_cast<PluginInstanceParent*>(

  1814         ::GetPropW(hWnd, kPluginInstanceParentProperty));

  1815     if (!self) {

  1816         NS_NOTREACHED("PluginInstanceParent::PluginWindowHookProc null this ptr!");

  1817         return DefWindowProc(hWnd, message, wParam, lParam);

  1818     }

  1820     NS_ASSERTION(self->mPluginHWND == hWnd, "Wrong window!");

  1822     switch (message) {

  1823         case WM_SETFOCUS:

  1824         // Let the child plugin window know it should take focus.

  1825         unused << self->CallSetPluginFocus();

  1826         break;

  1828         case WM_CLOSE:

  1829         self->UnsubclassPluginWindow();

  1830         break;

  1831     }

  1833     if (self->mPluginWndProc == PluginWindowHookProc) {

  1834       NS_NOTREACHED(

  1835         "PluginWindowHookProc invoking mPluginWndProc w/"

  1836         "mPluginWndProc == PluginWindowHookProc????");

  1837         return DefWindowProc(hWnd, message, wParam, lParam);

  1838     }

  1839     return ::CallWindowProc(self->mPluginWndProc, hWnd, message, wParam,

  1840                             lParam);

  1841 }

  1843 void

  1844 PluginInstanceParent::SubclassPluginWindow(HWND aWnd)

  1845 {

  1846     NS_ASSERTION(!(mPluginHWND && aWnd != mPluginHWND),

  1847       "PluginInstanceParent::SubclassPluginWindow hwnd is not our window!");

  1849     if (!mPluginHWND) {

  1850         mPluginHWND = aWnd;

  1851         mPluginWndProc =

  1852             (WNDPROC)::SetWindowLongPtrA(mPluginHWND, GWLP_WNDPROC,

  1853                          reinterpret_cast<LONG_PTR>(PluginWindowHookProc));

  1854         DebugOnly<bool> bRes = ::SetPropW(mPluginHWND, kPluginInstanceParentProperty, this);

  1855         NS_ASSERTION(mPluginWndProc,

  1856           "PluginInstanceParent::SubclassPluginWindow failed to set subclass!");

  1857         NS_ASSERTION(bRes,

  1858           "PluginInstanceParent::SubclassPluginWindow failed to set prop!");

  1859    }

  1860 }

  1862 void

  1863 PluginInstanceParent::UnsubclassPluginWindow()

  1864 {

  1865     if (mPluginHWND && mPluginWndProc) {

  1866         ::SetWindowLongPtrA(mPluginHWND, GWLP_WNDPROC,

  1867                             reinterpret_cast<LONG_PTR>(mPluginWndProc));

  1869         ::RemovePropW(mPluginHWND, kPluginInstanceParentProperty);

  1871         mPluginWndProc = nullptr;

  1872         mPluginHWND = nullptr;

  1873     }

  1874 }

  1876 /* windowless drawing helpers */

  1878 /*

  1879  * Origin info:

  1880  *

  1881  * windowless, offscreen:

  1882  *

  1883  * WM_WINDOWPOSCHANGED: origin is relative to container

  1884  * setwindow: origin is 0,0

  1885  * WM_PAINT: origin is 0,0

  1886  *

  1887  * windowless, native:

  1888  *

  1889  * WM_WINDOWPOSCHANGED: origin is relative to container

  1890  * setwindow: origin is relative to container

  1891  * WM_PAINT: origin is relative to container

  1892  *

  1893  * PluginInstanceParent:

  1894  *

  1895  * painting: mPluginPort (nsIntRect, saved in SetWindow)

  1896  */

  1898 void

  1899 PluginInstanceParent::SharedSurfaceRelease()

  1900 {

  1901     mSharedSurfaceDib.Close();

  1902 }

  1904 bool

  1905 PluginInstanceParent::SharedSurfaceSetWindow(const NPWindow* aWindow,

  1906                                              NPRemoteWindow& aRemoteWindow)

  1907 {

  1908     aRemoteWindow.window = 0;

  1909     aRemoteWindow.x      = aWindow->x;

  1910     aRemoteWindow.y      = aWindow->y;

  1911     aRemoteWindow.width  = aWindow->width;

  1912     aRemoteWindow.height = aWindow->height;

  1913     aRemoteWindow.type   = aWindow->type;

  1915     nsIntRect newPort(aWindow->x, aWindow->y, aWindow->width, aWindow->height);

  1917     // save the the rect location within the browser window.

  1918     mPluginPort = newPort;

  1920     // move the port to our shared surface origin

  1921     newPort.MoveTo(0,0);

  1923     // check to see if we have the room in shared surface

  1924     if (mSharedSurfaceDib.IsValid() && mSharedSize.Contains(newPort)) {

  1925       // ok to paint

  1926       aRemoteWindow.surfaceHandle = 0;

  1927       return true;

  1928     }

  1930     // allocate a new shared surface

  1931     SharedSurfaceRelease();

  1932     if (NS_FAILED(mSharedSurfaceDib.Create(reinterpret_cast<HDC>(aWindow->window),

  1933                                            newPort.width, newPort.height, false)))

  1934       return false;

  1936     // save the new shared surface size we just allocated

  1937     mSharedSize = newPort;

  1939     base::SharedMemoryHandle handle;

  1940     if (NS_FAILED(mSharedSurfaceDib.ShareToProcess(mParent->ChildProcessHandle(), &handle)))

  1941       return false;

  1943     aRemoteWindow.surfaceHandle = handle;

  1945     return true;

  1946 }

  1948 void

  1949 PluginInstanceParent::SharedSurfaceBeforePaint(RECT& rect,

  1950                                                NPRemoteEvent& npremoteevent)

  1951 {

  1952     RECT* dr = (RECT*)npremoteevent.event.lParam;

  1953     HDC parentHdc = (HDC)npremoteevent.event.wParam;

  1955     nsIntRect dirtyRect(dr->left, dr->top, dr->right-dr->left, dr->bottom-dr->top);

  1956     dirtyRect.MoveBy(-mPluginPort.x, -mPluginPort.y); // should always be smaller than dirtyRect

  1958     ::BitBlt(mSharedSurfaceDib.GetHDC(),

  1959              dirtyRect.x,

  1960              dirtyRect.y,

  1961              dirtyRect.width,

  1962              dirtyRect.height,

  1963              parentHdc,

  1964              dr->left,

  1965              dr->top,

  1966              SRCCOPY);

  1968     // setup the translated dirty rect we'll send to the child

  1969     rect.left   = dirtyRect.x;

  1970     rect.top    = dirtyRect.y;

  1971     rect.right  = dirtyRect.x + dirtyRect.width;

  1972     rect.bottom = dirtyRect.y + dirtyRect.height;

  1974     npremoteevent.event.wParam = WPARAM(0);

  1975     npremoteevent.event.lParam = LPARAM(&rect);

  1976 }

  1978 void

  1979 PluginInstanceParent::SharedSurfaceAfterPaint(NPEvent* npevent)

  1980 {

  1981     RECT* dr = (RECT*)npevent->lParam;

  1982     HDC parentHdc = (HDC)npevent->wParam;

  1984     nsIntRect dirtyRect(dr->left, dr->top, dr->right-dr->left, dr->bottom-dr->top);

  1985     dirtyRect.MoveBy(-mPluginPort.x, -mPluginPort.y);

  1987     // src copy the shared dib into the parent surface we are handed.

  1988     ::BitBlt(parentHdc,

  1989              dr->left,

  1990              dr->top,

  1991              dirtyRect.width,

  1992              dirtyRect.height,

  1993              mSharedSurfaceDib.GetHDC(),

  1994              dirtyRect.x,

  1995              dirtyRect.y,

  1996              SRCCOPY);

  1997 }

  1999 #endif // defined(OS_WIN)

  2001 bool

  2002 PluginInstanceParent::AnswerPluginFocusChange(const bool& gotFocus)

  2003 {

  2004     PLUGIN_LOG_DEBUG(("%s", FULLFUNCTION));

  2006     // Currently only in use on windows - an rpc event we receive from the

  2007     // child when it's plugin window (or one of it's children) receives keyboard

  2008     // focus. We forward the event down to widget so the dom/focus manager can

  2009     // be updated.

  2010 #if defined(OS_WIN)

  2011     ::SendMessage(mPluginHWND, gOOPPPluginFocusEvent, gotFocus ? 1 : 0, 0);

  2012     return true;

  2013 #else

  2014     NS_NOTREACHED("PluginInstanceParent::AnswerPluginFocusChange not implemented!");

  2015     return false;

  2016 #endif

  2017 }

The Tor Browser / file revision

dom/plugins/ipc/PluginInstanceParent.cpp@6474c204b198

dom/plugins/ipc/PluginInstanceParent.cpp