LCOV - app.info - dom/plugins/ipc/PluginInstanceParent.cpp

LCOV - code coverage report
| Current view: | directory - dom/plugins/ipc - PluginInstanceParent.cpp (source / functions) |  | Found | Hit | Coverage |
| Test: | app.info | Lines: | 511 | 0 | 0.0 %
| Date: | 2012-06-02 | Functions: | 74 | 0 | 0.0 %

           1                 : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
           2                 :  * vim: sw=4 ts=4 et :
           3                 :  * ***** BEGIN LICENSE BLOCK *****
           4                 :  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
           5                 :  *
           6                 :  * The contents of this file are subject to the Mozilla Public License Version
           7                 :  * 1.1 (the "License"); you may not use this file except in compliance with
           8                 :  * the License. You may obtain a copy of the License at
           9                 :  * http://www.mozilla.org/MPL/
          10                 :  *
          11                 :  * Software distributed under the License is distributed on an "AS IS" basis,
          12                 :  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
          13                 :  * for the specific language governing rights and limitations under the
          14                 :  * License.
          15                 :  *
          16                 :  * The Original Code is Mozilla Plugin App.
          17                 :  *
          18                 :  * The Initial Developer of the Original Code is
          19                 :  *   Chris Jones <jones.chris.g@gmail.com>
          20                 :  * Portions created by the Initial Developer are Copyright (C) 2009
          21                 :  * the Initial Developer. All Rights Reserved.
          22                 :  *
          23                 :  * Contributor(s):
          24                 :  *   Jim Mathies <jmathies@mozilla.com>
          25                 :  *
          26                 :  * Alternatively, the contents of this file may be used under the terms of
          27                 :  * either the GNU General Public License Version 2 or later (the "GPL"), or
          28                 :  * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
          29                 :  * in which case the provisions of the GPL or the LGPL are applicable instead
          30                 :  * of those above. If you wish to allow use of your version of this file only
          31                 :  * under the terms of either the GPL or the LGPL, and not to allow others to
          32                 :  * use your version of this file under the terms of the MPL, indicate your
          33                 :  * decision by deleting the provisions above and replace them with the notice
          34                 :  * and other provisions required by the GPL or the LGPL. If you do not delete
          35                 :  * the provisions above, a recipient may use your version of this file under
          36                 :  * the terms of any one of the MPL, the GPL or the LGPL.
          37                 :  *
          38                 :  * ***** END LICENSE BLOCK ***** */
          39                 :
          40                 : #include "PluginInstanceParent.h"
          41                 : #include "BrowserStreamParent.h"
          42                 : #include "PluginBackgroundDestroyer.h"
          43                 : #include "PluginModuleParent.h"
          44                 : #include "PluginStreamParent.h"
          45                 : #include "StreamNotifyParent.h"
          46                 : #include "npfunctions.h"
          47                 : #include "nsAutoPtr.h"
          48                 : #include "mozilla/unused.h"
          49                 : #include "gfxASurface.h"
          50                 : #include "gfxContext.h"
          51                 : #include "gfxPlatform.h"
          52                 : #include "gfxSharedImageSurface.h"
          53                 : #include "nsNPAPIPluginInstance.h"
          54                 : #ifdef MOZ_X11
          55                 : #include "gfxXlibSurface.h"
          56                 : #endif
          57                 : #include "gfxContext.h"
          58                 : #include "gfxColor.h"
          59                 : #include "gfxUtils.h"
          60                 : #include "nsNPAPIPluginInstance.h"
          61                 :
          62                 : #if defined(OS_WIN)
          63                 : #include <windowsx.h>
          64                 : #include "mozilla/plugins/PluginSurfaceParent.h"
          65                 :
          66                 : // Plugin focus event for widget.
          67                 : extern const PRUnichar* kOOPPPluginFocusEventId;
          68                 : UINT gOOPPPluginFocusEvent =
          69                 :     RegisterWindowMessage(kOOPPPluginFocusEventId);
          70                 : extern const PRUnichar* kFlashFullscreenClass;
          71                 : #elif defined(MOZ_WIDGET_GTK2)
          72                 : #include <gdk/gdk.h>
          73                 : #elif defined(XP_MACOSX)
          74                 : #include <ApplicationServices/ApplicationServices.h>
          75                 : #endif // defined(XP_MACOSX)
          76                 :
          77                 : using namespace mozilla::plugins;
          78                 :
          79                 : bool
          80               0 : StreamNotifyParent::RecvRedirectNotifyResponse(const bool& allow)
          81                 : {
          82               0 :   PluginInstanceParent* instance = static_cast<PluginInstanceParent*>(Manager());
          83               0 :   instance->mNPNIface->urlredirectresponse(instance->mNPP, this, static_cast<NPBool>(allow));
          84               0 :   return true;
          85                 : }
          86                 :
          87               0 : PluginInstanceParent::PluginInstanceParent(PluginModuleParent* parent,
          88                 :                                            NPP npp,
          89                 :                                            const nsCString& aMimeType,
          90                 :                                            const NPNetscapeFuncs* npniface)
          91                 :   : mParent(parent)
          92                 :     , mNPP(npp)
          93                 :     , mNPNIface(npniface)
          94                 :     , mWindowType(NPWindowTypeWindow)
          95               0 :     , mDrawingModel(kDefaultDrawingModel)
          96                 : #if defined(OS_WIN)
          97                 :     , mPluginHWND(NULL)
          98                 :     , mPluginWndProc(NULL)
          99                 :     , mNestedEventState(false)
         100                 : #endif // defined(XP_WIN)
         101                 : #if defined(XP_MACOSX)
         102                 :     , mShWidth(0)
         103                 :     , mShHeight(0)
         104                 :     , mShColorSpace(nsnull)
         105                 : #endif
         106                 : {
         107               0 : }
         108                 :
         109               0 : PluginInstanceParent::~PluginInstanceParent()
         110                 : {
         111               0 :     if (mNPP)
         112               0 :         mNPP->pdata = NULL;
         113                 :
         114                 : #if defined(OS_WIN)
         115                 :     NS_ASSERTION(!(mPluginHWND || mPluginWndProc),
         116                 :         "Subclass was not reset correctly before the dtor was reached!");
         117                 : #endif
         118                 : #if defined(MOZ_WIDGET_COCOA)
         119                 :     if (mShWidth != 0 && mShHeight != 0) {
         120                 :         DeallocShmem(mShSurface);
         121                 :     }
         122                 :     if (mShColorSpace)
         123                 :         ::CGColorSpaceRelease(mShColorSpace);
         124                 : #endif
         125               0 :     if (mRemoteImageDataShmem.IsWritable()) {
         126                 :         ImageContainer *container =
         127               0 :             GetImageContainer();
         128                 :
         129               0 :         if (container) {
         130               0 :             container->SetRemoteImageData(nsnull, nsnull);
         131               0 :             container->SetCompositionNotifySink(nsnull);
         132               0 :             DeallocShmem(mRemoteImageDataShmem);
         133                 :         }
         134                 :     }
         135               0 : }
         136                 :
         137                 : bool
         138               0 : PluginInstanceParent::Init()
         139                 : {
         140               0 :     return !!mScriptableObjects.Init();
         141                 : }
         142                 :
         143                 : void
         144               0 : PluginInstanceParent::ActorDestroy(ActorDestroyReason why)
         145                 : {
         146                 : #if defined(OS_WIN)
         147                 :     if (why == AbnormalShutdown) {
         148                 :         // If the plugin process crashes, this is the only
         149                 :         // chance we get to destroy resources.
         150                 :         SharedSurfaceRelease();
         151                 :         UnsubclassPluginWindow();
         152                 :     }
         153                 : #endif
         154                 :     // After this method, the data backing the remote surface may no
         155                 :     // longer be calid. The X surface may be destroyed, or the shared
         156                 :     // memory backing this surface may no longer be valid. The right
         157                 :     // way to inform the nsObjectFrame that the surface is no longer
         158                 :     // valid is with an invalidate call.
         159               0 :     if (mFrontSurface) {
         160               0 :         mFrontSurface = NULL;
         161               0 :         const NPRect rect = {0, 0, 0, 0};
         162               0 :         RecvNPN_InvalidateRect(rect);
         163                 : #ifdef MOZ_X11
         164               0 :         XSync(DefaultXDisplay(), False);
         165                 : #endif
         166                 :     }
         167               0 : }
         168                 :
         169                 : NPError
         170               0 : PluginInstanceParent::Destroy()
         171                 : {
         172                 :     NPError retval;
         173               0 :     if (!CallNPP_Destroy(&retval))
         174               0 :         retval = NPERR_GENERIC_ERROR;
         175                 :
         176                 : #if defined(OS_WIN)
         177                 :     SharedSurfaceRelease();
         178                 :     UnsubclassPluginWindow();
         179                 : #endif
         180                 :
         181               0 :     return retval;
         182                 : }
         183                 :
         184                 : PBrowserStreamParent*
         185               0 : PluginInstanceParent::AllocPBrowserStream(const nsCString& url,
         186                 :                                           const uint32_t& length,
         187                 :                                           const uint32_t& lastmodified,
         188                 :                                           PStreamNotifyParent* notifyData,
         189                 :                                           const nsCString& headers,
         190                 :                                           const nsCString& mimeType,
         191                 :                                           const bool& seekable,
         192                 :                                           NPError* rv,
         193                 :                                           uint16_t *stype)
         194                 : {
         195               0 :     NS_RUNTIMEABORT("Not reachable");
         196               0 :     return NULL;
         197                 : }
         198                 :
         199                 : bool
         200               0 : PluginInstanceParent::DeallocPBrowserStream(PBrowserStreamParent* stream)
         201                 : {
         202               0 :     delete stream;
         203               0 :     return true;
         204                 : }
         205                 :
         206                 : PPluginStreamParent*
         207               0 : PluginInstanceParent::AllocPPluginStream(const nsCString& mimeType,
         208                 :                                          const nsCString& target,
         209                 :                                          NPError* result)
         210                 : {
         211               0 :     return new PluginStreamParent(this, mimeType, target, result);
         212                 : }
         213                 :
         214                 : bool
         215               0 : PluginInstanceParent::DeallocPPluginStream(PPluginStreamParent* stream)
         216                 : {
         217               0 :     delete stream;
         218               0 :     return true;
         219                 : }
         220                 :
         221                 : bool
         222               0 : PluginInstanceParent::AnswerNPN_GetValue_NPNVjavascriptEnabledBool(
         223                 :                                                        bool* value,
         224                 :                                                        NPError* result)
         225                 : {
         226                 :     NPBool v;
         227               0 :     *result = mNPNIface->getvalue(mNPP, NPNVjavascriptEnabledBool, &v);
         228               0 :     *value = v;
         229               0 :     return true;
         230                 : }
         231                 :
         232                 : bool
         233               0 : PluginInstanceParent::AnswerNPN_GetValue_NPNVisOfflineBool(bool* value,
         234                 :                                                            NPError* result)
         235                 : {
         236                 :     NPBool v;
         237               0 :     *result = mNPNIface->getvalue(mNPP, NPNVisOfflineBool, &v);
         238               0 :     *value = v;
         239               0 :     return true;
         240                 : }
         241                 :
         242                 : bool
         243               0 : PluginInstanceParent::AnswerNPN_GetValue_NPNVnetscapeWindow(NativeWindowHandle* value,
         244                 :                                                             NPError* result)
         245                 : {
         246                 : #ifdef XP_WIN
         247                 :     HWND id;
         248                 : #elif defined(MOZ_X11)
         249                 :     XID id;
         250                 : #elif defined(XP_MACOSX)
         251                 :     intptr_t id;
         252                 : #elif defined(ANDROID)
         253                 : #warning Need Android impl
         254                 :     int id;
         255                 : #elif defined(MOZ_WIDGET_QT)
         256                 : #  warning Need Qt non X impl
         257                 :     int id;
         258                 : #else
         259                 : #warning Implement me
         260                 : #endif
         261                 :
         262               0 :     *result = mNPNIface->getvalue(mNPP, NPNVnetscapeWindow, &id);
         263               0 :     *value = id;
         264               0 :     return true;
         265                 : }
         266                 :
         267                 : bool
         268               0 : PluginInstanceParent::InternalGetValueForNPObject(
         269                 :                                          NPNVariable aVariable,
         270                 :                                          PPluginScriptableObjectParent** aValue,
         271                 :                                          NPError* aResult)
         272                 : {
         273                 :     NPObject* npobject;
         274               0 :     NPError result = mNPNIface->getvalue(mNPP, aVariable, (void*)&npobject);
         275               0 :     if (result == NPERR_NO_ERROR) {
         276               0 :         NS_ASSERTION(npobject, "Shouldn't return null and NPERR_NO_ERROR!");
         277                 :
         278               0 :         PluginScriptableObjectParent* actor = GetActorForNPObject(npobject);
         279               0 :         mNPNIface->releaseobject(npobject);
         280               0 :         if (actor) {
         281               0 :             *aValue = actor;
         282               0 :             *aResult = NPERR_NO_ERROR;
         283               0 :             return true;
         284                 :         }
         285                 :
         286               0 :         NS_ERROR("Failed to get actor!");
         287               0 :         result = NPERR_GENERIC_ERROR;
         288                 :     }
         289                 :
         290               0 :     *aValue = nsnull;
         291               0 :     *aResult = result;
         292               0 :     return true;
         293                 : }
         294                 :
         295                 : bool
         296               0 : PluginInstanceParent::IsAsyncDrawing()
         297                 : {
         298               0 :   return IsDrawingModelAsync(mDrawingModel);
         299                 : }
         300                 :
         301                 : bool
         302               0 : PluginInstanceParent::AnswerNPN_GetValue_NPNVWindowNPObject(
         303                 :                                          PPluginScriptableObjectParent** aValue,
         304                 :                                          NPError* aResult)
         305                 : {
         306               0 :     return InternalGetValueForNPObject(NPNVWindowNPObject, aValue, aResult);
         307                 : }
         308                 :
         309                 : bool
         310               0 : PluginInstanceParent::AnswerNPN_GetValue_NPNVPluginElementNPObject(
         311                 :                                          PPluginScriptableObjectParent** aValue,
         312                 :                                          NPError* aResult)
         313                 : {
         314                 :     return InternalGetValueForNPObject(NPNVPluginElementNPObject, aValue,
         315               0 :                                        aResult);
         316                 : }
         317                 :
         318                 : bool
         319               0 : PluginInstanceParent::AnswerNPN_GetValue_NPNVprivateModeBool(bool* value,
         320                 :                                                              NPError* result)
         321                 : {
         322                 :     NPBool v;
         323               0 :     *result = mNPNIface->getvalue(mNPP, NPNVprivateModeBool, &v);
         324               0 :     *value = v;
         325               0 :     return true;
         326                 : }
         327                 :
         328                 : bool
         329               0 : PluginInstanceParent::AnswerNPN_GetValue_NPNVdocumentOrigin(nsCString* value,
         330                 :                                                             NPError* result)
         331                 : {
         332               0 :     void *v = nsnull;
         333               0 :     *result = mNPNIface->getvalue(mNPP, NPNVdocumentOrigin, &v);
         334               0 :     if (*result == NPERR_NO_ERROR && v) {
         335               0 :         value->Adopt(static_cast<char*>(v));
         336                 :     }
         337               0 :     return true;
         338                 : }
         339                 :
         340                 : bool
         341               0 : PluginInstanceParent::AnswerNPN_SetValue_NPPVpluginWindow(
         342                 :     const bool& windowed, NPError* result)
         343                 : {
         344               0 :     NPBool isWindowed = windowed;
         345                 :     *result = mNPNIface->setvalue(mNPP, NPPVpluginWindowBool,
         346               0 :                                   (void*)isWindowed);
         347               0 :     return true;
         348                 : }
         349                 :
         350                 : bool
         351               0 : PluginInstanceParent::AnswerNPN_SetValue_NPPVpluginTransparent(
         352                 :     const bool& transparent, NPError* result)
         353                 : {
         354               0 :     NPBool isTransparent = transparent;
         355                 :     *result = mNPNIface->setvalue(mNPP, NPPVpluginTransparentBool,
         356               0 :                                   (void*)isTransparent);
         357               0 :     return true;
         358                 : }
         359                 :
         360                 : bool
         361               0 : PluginInstanceParent::AnswerNPN_SetValue_NPPVpluginUsesDOMForCursor(
         362                 :     const bool& useDOMForCursor, NPError* result)
         363                 : {
         364                 :     *result = mNPNIface->setvalue(mNPP, NPPVpluginUsesDOMForCursorBool,
         365               0 :                                   (void*)(NPBool)useDOMForCursor);
         366               0 :     return true;
         367                 : }
         368                 :
         369                 : class NotificationSink : public CompositionNotifySink
         370                 : {
         371                 : public:
         372               0 :   NotificationSink(PluginInstanceParent *aInstance) : mInstance(aInstance)
         373               0 :   { }
         374                 :
         375               0 :   virtual void DidComposite() { mInstance->DidComposite(); }
         376                 : private:
         377                 :   PluginInstanceParent *mInstance;
         378                 : };
         379                 :
         380                 : bool
         381               0 : PluginInstanceParent::AnswerNPN_SetValue_NPPVpluginDrawingModel(
         382                 :     const int& drawingModel, OptionalShmem *shmem, CrossProcessMutexHandle *mutex, NPError* result)
         383                 : {
         384                 : #ifdef XP_MACOSX
         385                 :     if (drawingModel == NPDrawingModelCoreAnimation ||
         386                 :         drawingModel == NPDrawingModelInvalidatingCoreAnimation) {
         387                 :         // We need to request CoreGraphics otherwise
         388                 :         // the nsObjectFrame will try to draw a CALayer
         389                 :         // that can not be shared across process.
         390                 :         mDrawingModel = drawingModel;
         391                 :         *result = mNPNIface->setvalue(mNPP, NPPVpluginDrawingModel,
         392                 :                                   (void*)NPDrawingModelCoreGraphics);
         393                 :         *shmem = null_t();
         394                 :     } else
         395                 : #endif
         396               0 :     if (drawingModel == NPDrawingModelAsyncBitmapSurface) {
         397               0 :         ImageContainer *container = GetImageContainer();
         398               0 :         if (!container) {
         399               0 :             *result = NPERR_GENERIC_ERROR;
         400               0 :             return true;
         401                 :         }
         402                 :
         403               0 :         mDrawingModel = drawingModel;
         404                 :         *result = mNPNIface->setvalue(mNPP, NPPVpluginDrawingModel,
         405               0 :                                         (void*)drawingModel);
         406                 :
         407                 :
         408               0 :         if (*result != NPERR_NO_ERROR) {
         409               0 :             return true;
         410                 :         }
         411                 :
         412               0 :         AllocUnsafeShmem(sizeof(RemoteImageData), SharedMemory::TYPE_BASIC, &mRemoteImageDataShmem);
         413                 :
         414               0 :         *shmem = mRemoteImageDataShmem;
         415                 :
         416               0 :         mRemoteImageDataMutex = new CrossProcessMutex("PluginInstanceParent.mRemoteImageDataMutex");
         417                 :
         418               0 :         *mutex = mRemoteImageDataMutex->ShareToProcess(OtherProcess());
         419               0 :         container->SetRemoteImageData(mRemoteImageDataShmem.get<RemoteImageData>(), mRemoteImageDataMutex);
         420                 :
         421               0 :         mNotifySink = new NotificationSink(this);
         422                 :
         423               0 :         container->SetCompositionNotifySink(mNotifySink);
         424               0 :     } else if (
         425                 : #if defined(XP_WIN)
         426                 :                drawingModel == NPDrawingModelSyncWin
         427                 : #elif defined(XP_MACOSX)
         428                 : #ifndef NP_NO_QUICKDRAW
         429                 :                drawingModel == NPDrawingModelQuickDraw ||
         430                 : #endif
         431                 :                drawingModel == NPDrawingModelOpenGL ||
         432                 :                drawingModel == NPDrawingModelCoreGraphics
         433                 : #elif defined(MOZ_X11)
         434                 :                drawingModel == NPDrawingModelSyncX
         435                 : #else
         436                 :                false
         437                 : #endif
         438                 :                ) {
         439               0 :         *shmem = null_t();
         440                 :
         441               0 :         ImageContainer *container = GetImageContainer();
         442               0 :         if (!container) {
         443               0 :             *result = NPERR_GENERIC_ERROR;
         444               0 :             return true;
         445                 :         }
         446                 :
         447               0 :         mDrawingModel = drawingModel;
         448                 :         *result = mNPNIface->setvalue(mNPP, NPPVpluginDrawingModel,
         449               0 :                                       (void*)drawingModel);
         450                 :
         451               0 :         if (mRemoteImageDataShmem.IsWritable()) {
         452               0 :             container->SetRemoteImageData(nsnull, nsnull);
         453               0 :             container->SetCompositionNotifySink(nsnull);
         454               0 :             DeallocShmem(mRemoteImageDataShmem);
         455               0 :             mRemoteImageDataMutex = NULL;
         456                 :         }
         457                 :     } else {
         458               0 :         *result = NPERR_GENERIC_ERROR;
         459                 :     }
         460               0 :     return true;
         461                 : }
         462                 :
         463                 : bool
         464               0 : PluginInstanceParent::AnswerNPN_SetValue_NPPVpluginEventModel(
         465                 :     const int& eventModel, NPError* result)
         466                 : {
         467                 : #ifdef XP_MACOSX
         468                 :     *result = mNPNIface->setvalue(mNPP, NPPVpluginEventModel,
         469                 :                                   (void*)eventModel);
         470                 :     return true;
         471                 : #else
         472               0 :     *result = NPERR_GENERIC_ERROR;
         473               0 :     return true;
         474                 : #endif
         475                 : }
         476                 :
         477                 : bool
         478               0 : PluginInstanceParent::AnswerNPN_GetURL(const nsCString& url,
         479                 :                                        const nsCString& target,
         480                 :                                        NPError* result)
         481                 : {
         482                 :     *result = mNPNIface->geturl(mNPP,
         483                 :                                 NullableStringGet(url),
         484               0 :                                 NullableStringGet(target));
         485               0 :     return true;
         486                 : }
         487                 :
         488                 : bool
         489               0 : PluginInstanceParent::AnswerNPN_PostURL(const nsCString& url,
         490                 :                                         const nsCString& target,
         491                 :                                         const nsCString& buffer,
         492                 :                                         const bool& file,
         493                 :                                         NPError* result)
         494                 : {
         495                 :     *result = mNPNIface->posturl(mNPP, url.get(), NullableStringGet(target),
         496               0 :                                  buffer.Length(), buffer.get(), file);
         497               0 :     return true;
         498                 : }
         499                 :
         500                 : PStreamNotifyParent*
         501               0 : PluginInstanceParent::AllocPStreamNotify(const nsCString& url,
         502                 :                                          const nsCString& target,
         503                 :                                          const bool& post,
         504                 :                                          const nsCString& buffer,
         505                 :                                          const bool& file,
         506                 :                                          NPError* result)
         507                 : {
         508               0 :     return new StreamNotifyParent();
         509                 : }
         510                 :
         511                 : bool
         512               0 : PluginInstanceParent::AnswerPStreamNotifyConstructor(PStreamNotifyParent* actor,
         513                 :                                                      const nsCString& url,
         514                 :                                                      const nsCString& target,
         515                 :                                                      const bool& post,
         516                 :                                                      const nsCString& buffer,
         517                 :                                                      const bool& file,
         518                 :                                                      NPError* result)
         519                 : {
         520               0 :     bool streamDestroyed = false;
         521                 :     static_cast<StreamNotifyParent*>(actor)->
         522               0 :         SetDestructionFlag(&streamDestroyed);
         523                 :
         524               0 :     if (!post) {
         525                 :         *result = mNPNIface->geturlnotify(mNPP,
         526                 :                                           NullableStringGet(url),
         527                 :                                           NullableStringGet(target),
         528               0 :                                           actor);
         529                 :     }
         530                 :     else {
         531                 :         *result = mNPNIface->posturlnotify(mNPP,
         532                 :                                            NullableStringGet(url),
         533                 :                                            NullableStringGet(target),
         534                 :                                            buffer.Length(),
         535                 :                                            NullableStringGet(buffer),
         536               0 :                                            file, actor);
         537                 :     }
         538                 :
         539               0 :     if (streamDestroyed) {
         540                 :         // If the stream was destroyed, we must return an error code in the
         541                 :         // constructor.
         542               0 :         *result = NPERR_GENERIC_ERROR;
         543                 :     }
         544                 :     else {
         545               0 :         static_cast<StreamNotifyParent*>(actor)->ClearDestructionFlag();
         546               0 :         if (*result != NPERR_NO_ERROR)
         547                 :             return PStreamNotifyParent::Send__delete__(actor,
         548               0 :                                                        NPERR_GENERIC_ERROR);
         549                 :     }
         550                 :
         551               0 :     return true;
         552                 : }
         553                 :
         554                 : bool
         555               0 : PluginInstanceParent::DeallocPStreamNotify(PStreamNotifyParent* notifyData)
         556                 : {
         557               0 :     delete notifyData;
         558               0 :     return true;
         559                 : }
         560                 :
         561                 : bool
         562               0 : PluginInstanceParent::RecvNPN_InvalidateRect(const NPRect& rect)
         563                 : {
         564               0 :     mNPNIface->invalidaterect(mNPP, const_cast<NPRect*>(&rect));
         565               0 :     return true;
         566                 : }
         567                 :
         568                 : bool
         569               0 : PluginInstanceParent::RecvShow(const NPRect& updatedRect,
         570                 :                                const SurfaceDescriptor& newSurface,
         571                 :                                SurfaceDescriptor* prevSurface)
         572                 : {
         573               0 :     PLUGIN_LOG_DEBUG(
         574                 :         ("[InstanceParent][%p] RecvShow for <x=%d,y=%d, w=%d,h=%d>",
         575                 :          this, updatedRect.left, updatedRect.top,
         576                 :          updatedRect.right - updatedRect.left,
         577                 :          updatedRect.bottom - updatedRect.top));
         578                 :
         579               0 :     nsRefPtr<gfxASurface> surface;
         580               0 :     if (newSurface.type() == SurfaceDescriptor::TShmem) {
         581               0 :         if (!newSurface.get_Shmem().IsReadable()) {
         582               0 :             NS_WARNING("back surface not readable");
         583               0 :             return false;
         584                 :         }
         585               0 :         surface = gfxSharedImageSurface::Open(newSurface.get_Shmem());
         586                 :     }
         587                 : #ifdef XP_MACOSX
         588                 :     else if (newSurface.type() == SurfaceDescriptor::TIOSurfaceDescriptor) {
         589                 :         IOSurfaceDescriptor iodesc = newSurface.get_IOSurfaceDescriptor();
         590                 :
         591                 :         nsRefPtr<nsIOSurface> newIOSurface = nsIOSurface::LookupSurface(iodesc.surfaceId());
         592                 :
         593                 :         if (!newIOSurface) {
         594                 :             NS_WARNING("Got bad IOSurfaceDescriptor in RecvShow");
         595                 :             return false;
         596                 :         }
         597                 :
         598                 :         if (mFrontIOSurface)
         599                 :             *prevSurface = IOSurfaceDescriptor(mFrontIOSurface->GetIOSurfaceID());
         600                 :         else
         601                 :             *prevSurface = null_t();
         602                 :
         603                 :         mFrontIOSurface = newIOSurface;
         604                 :
         605                 :         RecvNPN_InvalidateRect(updatedRect);
         606                 :
         607                 :         PLUGIN_LOG_DEBUG(("   (RecvShow invalidated for surface %p)",
         608                 :                           mFrontSurface.get()));
         609                 :
         610                 :         return true;
         611                 :     }
         612                 : #endif
         613                 : #ifdef MOZ_X11
         614               0 :     else if (newSurface.type() == SurfaceDescriptor::TSurfaceDescriptorX11) {
         615               0 :         surface = newSurface.get_SurfaceDescriptorX11().OpenForeign();
         616                 :     }
         617                 : #endif
         618                 : #ifdef XP_WIN
         619                 :     else if (newSurface.type() == SurfaceDescriptor::TPPluginSurfaceParent) {
         620                 :         PluginSurfaceParent* s =
         621                 :             static_cast<PluginSurfaceParent*>(newSurface.get_PPluginSurfaceParent());
         622                 :         surface = s->Surface();
         623                 :     }
         624                 : #endif
         625                 :
         626                 : #ifdef MOZ_X11
         627               0 :     if (mFrontSurface &&
         628               0 :         mFrontSurface->GetType() == gfxASurface::SurfaceTypeXlib)
         629                 :         // This is the "old front buffer" we're about to hand back to
         630                 :         // the plugin.  We might still have drawing operations
         631                 :         // referencing it, so we XSync here to let them finish before
         632                 :         // the plugin starts scribbling on it again, or worse,
         633                 :         // destroys it.
         634               0 :         XSync(DefaultXDisplay(), False);
         635                 : #endif
         636                 :
         637               0 :     if (mFrontSurface && gfxSharedImageSurface::IsSharedImage(mFrontSurface))
         638               0 :         *prevSurface = static_cast<gfxSharedImageSurface*>(mFrontSurface.get())->GetShmem();
         639                 :     else
         640               0 :         *prevSurface = null_t();
         641                 :
         642               0 :     if (surface) {
         643                 :         // Notify the cairo backend that this surface has changed behind
         644                 :         // its back.
         645                 :         gfxRect ur(updatedRect.left, updatedRect.top,
         646                 :                    updatedRect.right - updatedRect.left,
         647               0 :                    updatedRect.bottom - updatedRect.top);
         648               0 :         surface->MarkDirty(ur);
         649               0 :         surface->Flush();
         650                 :     }
         651                 :
         652               0 :     mFrontSurface = surface;
         653               0 :     RecvNPN_InvalidateRect(updatedRect);
         654                 :
         655               0 :     PLUGIN_LOG_DEBUG(("   (RecvShow invalidated for surface %p)",
         656                 :                       mFrontSurface.get()));
         657                 :
         658               0 :     return true;
         659                 : }
         660                 :
         661                 : nsresult
         662               0 : PluginInstanceParent::AsyncSetWindow(NPWindow* aWindow)
         663                 : {
         664               0 :     NPRemoteWindow window;
         665               0 :     mWindowType = aWindow->type;
         666               0 :     window.window = reinterpret_cast<uint64_t>(aWindow->window);
         667               0 :     window.x = aWindow->x;
         668               0 :     window.y = aWindow->y;
         669               0 :     window.width = aWindow->width;
         670               0 :     window.height = aWindow->height;
         671               0 :     window.clipRect = aWindow->clipRect;
         672               0 :     window.type = aWindow->type;
         673               0 :     if (!SendAsyncSetWindow(gfxPlatform::GetPlatform()->ScreenReferenceSurface()->GetType(),
         674               0 :                             window))
         675               0 :         return NS_ERROR_FAILURE;
         676                 :
         677               0 :     return NS_OK;
         678                 : }
         679                 :
         680                 : #if defined(MOZ_WIDGET_QT) && (MOZ_PLATFORM_MAEMO == 6)
         681                 : nsresult
         682                 : PluginInstanceParent::HandleGUIEvent(const nsGUIEvent& anEvent, bool* handled)
         683                 : {
         684                 :     switch (anEvent.eventStructType) {
         685                 :     case NS_KEY_EVENT:
         686                 :         if (!CallHandleKeyEvent(static_cast<const nsKeyEvent&>(anEvent),
         687                 :                                 handled)) {
         688                 :             return NS_ERROR_FAILURE;
         689                 :         }
         690                 :         break;
         691                 :     case NS_TEXT_EVENT:
         692                 :         if (!CallHandleTextEvent(static_cast<const nsTextEvent&>(anEvent),
         693                 :                                  handled)) {
         694                 :             return NS_ERROR_FAILURE;
         695                 :         }
         696                 :         break;
         697                 :     default:
         698                 :         NS_ERROR("Not implemented for this event type");
         699                 :         return NS_ERROR_FAILURE;
         700                 :     }
         701                 :     return NS_OK;
         702                 : }
         703                 : #endif
         704                 :
         705                 : nsresult
         706               0 : PluginInstanceParent::GetImageContainer(ImageContainer** aContainer)
         707                 : {
         708                 : #ifdef XP_MACOSX
         709                 :     nsIOSurface* ioSurface = NULL;
         710                 :
         711                 :     if (mFrontIOSurface) {
         712                 :       ioSurface = mFrontIOSurface;
         713                 :     } else if (mIOSurface) {
         714                 :       ioSurface = mIOSurface;
         715                 :     }
         716                 :
         717                 :     if (!mFrontSurface && !ioSurface)
         718                 : #else
         719               0 :     if (!mFrontSurface)
         720                 : #endif
         721               0 :         return NS_ERROR_NOT_AVAILABLE;
         722                 :
         723               0 :     Image::Format format = Image::CAIRO_SURFACE;
         724                 : #ifdef XP_MACOSX
         725                 :     if (ioSurface) {
         726                 :         format = Image::MAC_IO_SURFACE;
         727                 :     }
         728                 : #endif
         729                 :
         730               0 :     ImageContainer *container = GetImageContainer();
         731                 :
         732               0 :     if (!container) {
         733               0 :         return NS_ERROR_FAILURE;
         734                 :     }
         735                 :
         736               0 :     if (IsAsyncDrawing()) {
         737               0 :       NS_IF_ADDREF(container);
         738               0 :       *aContainer = container;
         739               0 :       return NS_OK;
         740                 :     }
         741                 :
         742               0 :     nsRefPtr<Image> image;
         743               0 :     image = container->CreateImage(&format, 1);
         744               0 :     if (!image) {
         745               0 :         return NS_ERROR_FAILURE;
         746                 :     }
         747                 :
         748                 : #ifdef XP_MACOSX
         749                 :     if (ioSurface) {
         750                 :         NS_ASSERTION(image->GetFormat() == Image::MAC_IO_SURFACE, "Wrong format?");
         751                 :         MacIOSurfaceImage* ioImage = static_cast<MacIOSurfaceImage*>(image.get());
         752                 :         MacIOSurfaceImage::Data ioData;
         753                 :         ioData.mIOSurface = ioSurface;
         754                 :         ioImage->SetData(ioData);
         755                 :         container->SetCurrentImage(ioImage);
         756                 :
         757                 :         NS_IF_ADDREF(container);
         758                 :         *aContainer = container;
         759                 :         return NS_OK;
         760                 :     }
         761                 : #endif
         762                 :
         763               0 :     NS_ASSERTION(image->GetFormat() == Image::CAIRO_SURFACE, "Wrong format?");
         764               0 :     CairoImage* pluginImage = static_cast<CairoImage*>(image.get());
         765               0 :     CairoImage::Data cairoData;
         766               0 :     cairoData.mSurface = mFrontSurface;
         767               0 :     cairoData.mSize = mFrontSurface->GetSize();
         768               0 :     pluginImage->SetData(cairoData);
         769                 :
         770               0 :     container->SetCurrentImage(pluginImage);
         771                 :
         772               0 :     NS_IF_ADDREF(container);
         773               0 :     *aContainer = container;
         774               0 :     return NS_OK;
         775                 : }
         776                 :
         777                 : nsresult
         778               0 : PluginInstanceParent::GetImageSize(nsIntSize* aSize)
         779                 : {
         780               0 :     if (mFrontSurface) {
         781               0 :         gfxIntSize size = mFrontSurface->GetSize();
         782               0 :         *aSize = nsIntSize(size.width, size.height);
         783               0 :         return NS_OK;
         784                 :     }
         785                 :
         786                 : #ifdef XP_MACOSX
         787                 :     if (mFrontIOSurface) {
         788                 :         *aSize = nsIntSize(mFrontIOSurface->GetWidth(), mFrontIOSurface->GetHeight());
         789                 :         return NS_OK;
         790                 :     } else if (mIOSurface) {
         791                 :         *aSize = nsIntSize(mIOSurface->GetWidth(), mIOSurface->GetHeight());
         792                 :         return NS_OK;
         793                 :     }
         794                 : #endif
         795                 :
         796               0 :     return NS_ERROR_NOT_AVAILABLE;
         797                 : }
         798                 :
         799                 : #ifdef XP_MACOSX
         800                 : nsresult
         801                 : PluginInstanceParent::IsRemoteDrawingCoreAnimation(bool *aDrawing)
         802                 : {
         803                 :     *aDrawing = (NPDrawingModelCoreAnimation == (NPDrawingModel)mDrawingModel ||
         804                 :                  NPDrawingModelInvalidatingCoreAnimation == (NPDrawingModel)mDrawingModel);
         805                 :     return NS_OK;
         806                 : }
         807                 : #endif
         808                 :
         809                 : nsresult
         810               0 : PluginInstanceParent::SetBackgroundUnknown()
         811                 : {
         812               0 :     PLUGIN_LOG_DEBUG(("[InstanceParent][%p] SetBackgroundUnknown", this));
         813                 :
         814               0 :     if (mBackground) {
         815               0 :         DestroyBackground();
         816               0 :         NS_ABORT_IF_FALSE(!mBackground, "Background not destroyed");
         817                 :     }
         818                 :
         819               0 :     return NS_OK;
         820                 : }
         821                 :
         822                 : nsresult
         823               0 : PluginInstanceParent::BeginUpdateBackground(const nsIntRect& aRect,
         824                 :                                             gfxContext** aCtx)
         825                 : {
         826               0 :     PLUGIN_LOG_DEBUG(
         827                 :         ("[InstanceParent][%p] BeginUpdateBackground for <x=%d,y=%d, w=%d,h=%d>",
         828                 :          this, aRect.x, aRect.y, aRect.width, aRect.height));
         829                 :
         830               0 :     if (!mBackground) {
         831                 :         // XXX if we failed to create a background surface on one
         832                 :         // update, there's no guarantee that later updates will be for
         833                 :         // the entire background area until successful.  We might want
         834                 :         // to fix that eventually.
         835               0 :         NS_ABORT_IF_FALSE(aRect.TopLeft() == nsIntPoint(0, 0),
         836                 :                           "Expecting rect for whole frame");
         837               0 :         if (!CreateBackground(aRect.Size())) {
         838               0 :             *aCtx = nsnull;
         839               0 :             return NS_OK;
         840                 :         }
         841                 :     }
         842                 :
         843                 : #ifdef DEBUG
         844               0 :     gfxIntSize sz = mBackground->GetSize();
         845               0 :     NS_ABORT_IF_FALSE(nsIntRect(0, 0, sz.width, sz.height).Contains(aRect),
         846                 :                       "Update outside of background area");
         847                 : #endif
         848                 :
         849               0 :     nsRefPtr<gfxContext> ctx = new gfxContext(mBackground);
         850               0 :     *aCtx = ctx.forget().get();
         851                 :
         852               0 :     return NS_OK;
         853                 : }
         854                 :
         855                 : nsresult
         856               0 : PluginInstanceParent::EndUpdateBackground(gfxContext* aCtx,
         857                 :                                           const nsIntRect& aRect)
         858                 : {
         859               0 :     PLUGIN_LOG_DEBUG(
         860                 :         ("[InstanceParent][%p] EndUpdateBackground for <x=%d,y=%d, w=%d,h=%d>",
         861                 :          this, aRect.x, aRect.y, aRect.width, aRect.height));
         862                 :
         863                 : #ifdef MOZ_X11
         864                 :     // Have to XSync here to avoid the plugin trying to draw with this
         865                 :     // surface racing with its creation in the X server.  We also want
         866                 :     // to avoid the plugin drawing onto stale pixels, then handing us
         867                 :     // back a front surface from those pixels that we might
         868                 :     // recomposite for "a while" until the next update.  This XSync
         869                 :     // still doesn't guarantee that the plugin draws onto a consistent
         870                 :     // view of its background, but it does mean that the plugin is
         871                 :     // drawing onto pixels no older than those in the latest
         872                 :     // EndUpdateBackground().
         873               0 :     XSync(DefaultXDisplay(), False);
         874                 : #endif
         875                 :
         876               0 :     unused << SendUpdateBackground(BackgroundDescriptor(), aRect);
         877                 :
         878               0 :     return NS_OK;
         879                 : }
         880                 :
         881                 : bool
         882               0 : PluginInstanceParent::CreateBackground(const nsIntSize& aSize)
         883                 : {
         884               0 :     NS_ABORT_IF_FALSE(!mBackground, "Already have a background");
         885                 :
         886                 :     // XXX refactor me
         887                 :
         888                 : #if defined(MOZ_X11)
         889               0 :     Screen* screen = DefaultScreenOfDisplay(DefaultXDisplay());
         890               0 :     Visual* visual = DefaultVisualOfScreen(screen);
         891                 :     mBackground = gfxXlibSurface::Create(screen, visual,
         892               0 :                                          gfxIntSize(aSize.width, aSize.height));
         893               0 :     return !!mBackground;
         894                 :
         895                 : #elif defined(XP_WIN)
         896                 :     // We have chosen to create an unsafe surface in which the plugin
         897                 :     // can read from the region while we're writing to it.
         898                 :     mBackground =
         899                 :         gfxSharedImageSurface::CreateUnsafe(
         900                 :             this,
         901                 :             gfxIntSize(aSize.width, aSize.height),
         902                 :             gfxASurface::ImageFormatRGB24);
         903                 :     return !!mBackground;
         904                 : #else
         905                 :     return nsnull;
         906                 : #endif
         907                 : }
         908                 :
         909                 : void
         910               0 : PluginInstanceParent::DestroyBackground()
         911                 : {
         912               0 :     if (!mBackground) {
         913               0 :         return;
         914                 :     }
         915                 :
         916                 :     // Relinquish ownership of |mBackground| to its destroyer
         917                 :     PPluginBackgroundDestroyerParent* pbd =
         918               0 :         new PluginBackgroundDestroyerParent(mBackground);
         919               0 :     mBackground = nsnull;
         920                 :
         921                 :     // If this fails, there's no problem: |bd| will be destroyed along
         922                 :     // with the old background surface.
         923               0 :     unused << SendPPluginBackgroundDestroyerConstructor(pbd);
         924                 : }
         925                 :
         926                 : SurfaceDescriptor
         927               0 : PluginInstanceParent::BackgroundDescriptor()
         928                 : {
         929               0 :     NS_ABORT_IF_FALSE(mBackground, "Need a background here");
         930                 :
         931                 :     // XXX refactor me
         932                 :
         933                 : #ifdef MOZ_X11
         934               0 :     gfxXlibSurface* xsurf = static_cast<gfxXlibSurface*>(mBackground.get());
         935               0 :     return SurfaceDescriptorX11(xsurf);
         936                 : #endif
         937                 :
         938                 : #ifdef XP_WIN
         939                 :     NS_ABORT_IF_FALSE(gfxSharedImageSurface::IsSharedImage(mBackground),
         940                 :                       "Expected shared image surface");
         941                 :     gfxSharedImageSurface* shmem =
         942                 :         static_cast<gfxSharedImageSurface*>(mBackground.get());
         943                 :     return shmem->GetShmem();
         944                 : #endif
         945                 :
         946                 :     // If this is ever used, which it shouldn't be, it will trigger a
         947                 :     // hard assertion in IPDL-generated code.
         948                 :     return SurfaceDescriptor();
         949                 : }
         950                 :
         951                 : ImageContainer*
         952               0 : PluginInstanceParent::GetImageContainer()
         953                 : {
         954               0 :   if (mImageContainer) {
         955               0 :     return mImageContainer;
         956                 :   }
         957                 :
         958               0 :   mImageContainer = LayerManager::CreateImageContainer();
         959               0 :   return mImageContainer;
         960                 : }
         961                 :
         962                 : PPluginBackgroundDestroyerParent*
         963               0 : PluginInstanceParent::AllocPPluginBackgroundDestroyer()
         964                 : {
         965               0 :     NS_RUNTIMEABORT("'Power-user' ctor is used exclusively");
         966               0 :     return nsnull;
         967                 : }
         968                 :
         969                 : bool
         970               0 : PluginInstanceParent::DeallocPPluginBackgroundDestroyer(
         971                 :     PPluginBackgroundDestroyerParent* aActor)
         972                 : {
         973               0 :     delete aActor;
         974               0 :     return true;
         975                 : }
         976                 :
         977                 : NPError
         978               0 : PluginInstanceParent::NPP_SetWindow(const NPWindow* aWindow)
         979                 : {
         980               0 :     PLUGIN_LOG_DEBUG(("%s (aWindow=%p)", FULLFUNCTION, (void*) aWindow));
         981                 :
         982               0 :     NS_ENSURE_TRUE(aWindow, NPERR_GENERIC_ERROR);
         983                 :
         984               0 :     NPRemoteWindow window;
         985               0 :     mWindowType = aWindow->type;
         986                 :
         987                 : #if defined(OS_WIN)
         988                 :     // On windowless controls, reset the shared memory surface as needed.
         989                 :     if (mWindowType == NPWindowTypeDrawable) {
         990                 :         // SharedSurfaceSetWindow will take care of NPRemoteWindow.
         991                 :         if (!SharedSurfaceSetWindow(aWindow, window)) {
         992                 :           return NPERR_OUT_OF_MEMORY_ERROR;
         993                 :         }
         994                 :     }
         995                 :     else {
         996                 :         SubclassPluginWindow(reinterpret_cast<HWND>(aWindow->window));
         997                 :
         998                 :         window.window = reinterpret_cast<uint64_t>(aWindow->window);
         999                 :         window.x = aWindow->x;
        1000                 :         window.y = aWindow->y;
        1001                 :         window.width = aWindow->width;
        1002                 :         window.height = aWindow->height;
        1003                 :         window.type = aWindow->type;
        1004                 :     }
        1005                 : #else
        1006               0 :     window.window = reinterpret_cast<uint64_t>(aWindow->window);
        1007               0 :     window.x = aWindow->x;
        1008               0 :     window.y = aWindow->y;
        1009               0 :     window.width = aWindow->width;
        1010               0 :     window.height = aWindow->height;
        1011               0 :     window.clipRect = aWindow->clipRect; // MacOS specific
        1012               0 :     window.type = aWindow->type;
        1013                 : #endif
        1014                 :
        1015                 : #if defined(XP_MACOSX)
        1016                 :     if (mShWidth != window.width || mShHeight != window.height) {
        1017                 :         if (mDrawingModel == NPDrawingModelCoreAnimation ||
        1018                 :             mDrawingModel == NPDrawingModelInvalidatingCoreAnimation) {
        1019                 :             mIOSurface = nsIOSurface::CreateIOSurface(window.width, window.height);
        1020                 :         } else if (mShWidth * mShHeight != window.width * window.height) {
        1021                 :             if (mShWidth != 0 && mShHeight != 0) {
        1022                 :                 DeallocShmem(mShSurface);
        1023                 :                 mShWidth = 0;
        1024                 :                 mShHeight = 0;
        1025                 :             }
        1026                 :
        1027                 :             if (window.width != 0 && window.height != 0) {
        1028                 :                 if (!AllocShmem(window.width * window.height*4,
        1029                 :                                 SharedMemory::TYPE_BASIC, &mShSurface)) {
        1030                 :                     PLUGIN_LOG_DEBUG(("Shared memory could not be allocated."));
        1031                 :                     return NPERR_GENERIC_ERROR;
        1032                 :                 }
        1033                 :             }
        1034                 :         }
        1035                 :         mShWidth = window.width;
        1036                 :         mShHeight = window.height;
        1037                 :     }
        1038                 : #endif
        1039                 :
        1040                 : #if defined(MOZ_X11) && defined(XP_UNIX) && !defined(XP_MACOSX)
        1041                 :     const NPSetWindowCallbackStruct* ws_info =
        1042               0 :       static_cast<NPSetWindowCallbackStruct*>(aWindow->ws_info);
        1043               0 :     window.visualID = ws_info->visual ? ws_info->visual->visualid : None;
        1044               0 :     window.colormap = ws_info->colormap;
        1045                 : #endif
        1046                 :
        1047               0 :     if (!CallNPP_SetWindow(window))
        1048               0 :         return NPERR_GENERIC_ERROR;
        1049                 :
        1050               0 :     return NPERR_NO_ERROR;
        1051                 : }
        1052                 :
        1053                 : NPError
        1054               0 : PluginInstanceParent::NPP_GetValue(NPPVariable aVariable,
        1055                 :                                    void* _retval)
        1056                 : {
        1057               0 :     switch (aVariable) {
        1058                 :
        1059                 :     case NPPVpluginWantsAllNetworkStreams: {
        1060                 :         bool wantsAllStreams;
        1061                 :         NPError rv;
        1062                 :
        1063               0 :         if (!CallNPP_GetValue_NPPVpluginWantsAllNetworkStreams(&wantsAllStreams, &rv)) {
        1064               0 :             return NPERR_GENERIC_ERROR;
        1065                 :         }
        1066                 :
        1067               0 :         if (NPERR_NO_ERROR != rv) {
        1068               0 :             return rv;
        1069                 :         }
        1070                 :
        1071               0 :         (*(NPBool*)_retval) = wantsAllStreams;
        1072               0 :         return NPERR_NO_ERROR;
        1073                 :     }
        1074                 :
        1075                 : #ifdef MOZ_X11
        1076                 :     case NPPVpluginNeedsXEmbed: {
        1077                 :         bool needsXEmbed;
        1078                 :         NPError rv;
        1079                 :
        1080               0 :         if (!CallNPP_GetValue_NPPVpluginNeedsXEmbed(&needsXEmbed, &rv)) {
        1081               0 :             return NPERR_GENERIC_ERROR;
        1082                 :         }
        1083                 :
        1084               0 :         if (NPERR_NO_ERROR != rv) {
        1085               0 :             return rv;
        1086                 :         }
        1087                 :
        1088               0 :         (*(NPBool*)_retval) = needsXEmbed;
        1089               0 :         return NPERR_NO_ERROR;
        1090                 :     }
        1091                 : #endif
        1092                 :
        1093                 :     case NPPVpluginScriptableNPObject: {
        1094                 :         PPluginScriptableObjectParent* actor;
        1095                 :         NPError rv;
        1096               0 :         if (!CallNPP_GetValue_NPPVpluginScriptableNPObject(&actor, &rv)) {
        1097               0 :             return NPERR_GENERIC_ERROR;
        1098                 :         }
        1099                 :
        1100               0 :         if (NPERR_NO_ERROR != rv) {
        1101               0 :             return rv;
        1102                 :         }
        1103                 :
        1104               0 :         if (!actor) {
        1105               0 :             NS_ERROR("NPPVpluginScriptableNPObject succeeded but null.");
        1106               0 :             return NPERR_GENERIC_ERROR;
        1107                 :         }
        1108                 :
        1109               0 :         const NPNetscapeFuncs* npn = mParent->GetNetscapeFuncs();
        1110               0 :         if (!npn) {
        1111               0 :             NS_WARNING("No netscape functions?!");
        1112               0 :             return NPERR_GENERIC_ERROR;
        1113                 :         }
        1114                 :
        1115                 :         NPObject* object =
        1116               0 :             static_cast<PluginScriptableObjectParent*>(actor)->GetObject(true);
        1117               0 :         NS_ASSERTION(object, "This shouldn't ever be null!");
        1118                 :
        1119               0 :         (*(NPObject**)_retval) = npn->retainobject(object);
        1120               0 :         return NPERR_NO_ERROR;
        1121                 :     }
        1122                 :
        1123                 : #ifdef MOZ_ACCESSIBILITY_ATK
        1124                 :     case NPPVpluginNativeAccessibleAtkPlugId: {
        1125               0 :         nsCString plugId;
        1126                 :         NPError rv;
        1127               0 :         if (!CallNPP_GetValue_NPPVpluginNativeAccessibleAtkPlugId(&plugId, &rv)) {
        1128               0 :             return NPERR_GENERIC_ERROR;
        1129                 :         }
        1130                 :
        1131               0 :         if (NPERR_NO_ERROR != rv) {
        1132               0 :             return rv;
        1133                 :         }
        1134                 :
        1135               0 :         (*(nsCString*)_retval) = plugId;
        1136               0 :         return NPERR_NO_ERROR;
        1137                 :     }
        1138                 : #endif
        1139                 :
        1140                 :     default:
        1141               0 :         PR_LOG(gPluginLog, PR_LOG_WARNING,
        1142                 :                ("In PluginInstanceParent::NPP_GetValue: Unhandled NPPVariable %i (%s)",
        1143                 :                 (int) aVariable, NPPVariableToString(aVariable)));
        1144               0 :         return NPERR_GENERIC_ERROR;
        1145                 :     }
        1146                 : }
        1147                 :
        1148                 : NPError
        1149               0 : PluginInstanceParent::NPP_SetValue(NPNVariable variable, void* value)
        1150                 : {
        1151               0 :     switch (variable) {
        1152                 :     case NPNVprivateModeBool:
        1153                 :         NPError result;
        1154               0 :         if (!CallNPP_SetValue_NPNVprivateModeBool(*static_cast<NPBool*>(value),
        1155               0 :                                                   &result))
        1156               0 :             return NPERR_GENERIC_ERROR;
        1157                 :
        1158               0 :         return result;
        1159                 :
        1160                 :     default:
        1161               0 :         NS_ERROR("Unhandled NPNVariable in NPP_SetValue");
        1162               0 :         PR_LOG(gPluginLog, PR_LOG_WARNING,
        1163                 :                ("In PluginInstanceParent::NPP_SetValue: Unhandled NPNVariable %i (%s)",
        1164                 :                 (int) variable, NPNVariableToString(variable)));
        1165               0 :         return NPERR_GENERIC_ERROR;
        1166                 :     }
        1167                 : }
        1168                 :
        1169                 : void
        1170               0 : PluginInstanceParent::NPP_URLRedirectNotify(const char* url, int32_t status,
        1171                 :                                             void* notifyData)
        1172                 : {
        1173               0 :   if (!notifyData)
        1174               0 :     return;
        1175                 :
        1176               0 :   PStreamNotifyParent* streamNotify = static_cast<PStreamNotifyParent*>(notifyData);
        1177               0 :   unused << streamNotify->SendRedirectNotify(NullableString(url), status);
        1178                 : }
        1179                 :
        1180                 : int16_t
        1181               0 : PluginInstanceParent::NPP_HandleEvent(void* event)
        1182                 : {
        1183               0 :     PLUGIN_LOG_DEBUG_FUNCTION;
        1184                 :
        1185                 : #if defined(XP_MACOSX)
        1186                 :     NPCocoaEvent* npevent = reinterpret_cast<NPCocoaEvent*>(event);
        1187                 : #else
        1188               0 :     NPEvent* npevent = reinterpret_cast<NPEvent*>(event);
        1189                 : #endif
        1190                 :     NPRemoteEvent npremoteevent;
        1191               0 :     npremoteevent.event = *npevent;
        1192               0 :     int16_t handled = 0;
        1193                 :
        1194                 : #if defined(OS_WIN)
        1195                 :     if (mWindowType == NPWindowTypeDrawable) {
        1196                 :         if (IsAsyncDrawing()) {
        1197                 :             if (npevent->event == WM_PAINT || npevent->event == DoublePassRenderingEvent()) {
        1198                 :                 // This plugin maintains its own async drawing.
        1199                 :                 return handled;
        1200                 :             }
        1201                 :         }
        1202                 :         if (DoublePassRenderingEvent() == npevent->event) {
        1203                 :             CallPaint(npremoteevent, &handled);
        1204                 :             return handled;
        1205                 :         }
        1206                 :
        1207                 :         switch (npevent->event) {
        1208                 :             case WM_PAINT:
        1209                 :             {
        1210                 :                 RECT rect;
        1211                 :                 SharedSurfaceBeforePaint(rect, npremoteevent);
        1212                 :                 CallPaint(npremoteevent, &handled);
        1213                 :                 SharedSurfaceAfterPaint(npevent);
        1214                 :                 return handled;
        1215                 :             }
        1216                 :             break;
        1217                 :
        1218                 :             case WM_KILLFOCUS:
        1219                 :             {
        1220                 :               // When the user selects fullscreen mode in Flash video players,
        1221                 :               // WM_KILLFOCUS will be delayed by deferred event processing:
        1222                 :               // WM_LBUTTONUP results in a call to CreateWindow within Flash,
        1223                 :               // which fires WM_KILLFOCUS. Delayed delivery causes Flash to
        1224                 :               // misinterpret the event, dropping back out of fullscreen. Trap
        1225                 :               // this event and drop it.
        1226                 :               PRUnichar szClass[26];
        1227                 :               HWND hwnd = GetForegroundWindow();
        1228                 :               if (hwnd && hwnd != mPluginHWND &&
        1229                 :                   GetClassNameW(hwnd, szClass,
        1230                 :                                 sizeof(szClass)/sizeof(PRUnichar)) &&
        1231                 :                   !wcscmp(szClass, kFlashFullscreenClass)) {
        1232                 :                   return 0;
        1233                 :               }
        1234                 :             }
        1235                 :             break;
        1236                 :
        1237                 :             case WM_WINDOWPOSCHANGED:
        1238                 :             {
        1239                 :                 // We send this in nsObjectFrame just before painting
        1240                 :                 SendWindowPosChanged(npremoteevent);
        1241                 :                 // nsObjectFrame doesn't care whether we handle this
        1242                 :                 // or not, just returning 1 for good hygiene
        1243                 :                 return 1;
        1244                 :             }
        1245                 :             break;
        1246                 :         }
        1247                 :     }
        1248                 : #endif
        1249                 :
        1250                 : #if defined(MOZ_X11)
        1251               0 :     switch (npevent->type) {
        1252                 :     case GraphicsExpose:
        1253               0 :         PLUGIN_LOG_DEBUG(("  schlepping drawable 0x%lx across the pipe\n",
        1254                 :                           npevent->xgraphicsexpose.drawable));
        1255                 :         // Make sure the X server has created the Drawable and completes any
        1256                 :         // drawing before the plugin draws on top.
        1257                 :         //
        1258                 :         // XSync() waits for the X server to complete.  Really this parent
        1259                 :         // process does not need to wait; the child is the process that needs
        1260                 :         // to wait.  A possibly-slightly-better alternative would be to send
        1261                 :         // an X event to the child that the child would wait for.
        1262               0 :         XSync(DefaultXDisplay(), False);
        1263                 :
        1264               0 :         return CallPaint(npremoteevent, &handled) ? handled : 0;
        1265                 :
        1266                 :     case ButtonPress:
        1267                 :         // Release any active pointer grab so that the plugin X client can
        1268                 :         // grab the pointer if it wishes.
        1269               0 :         Display *dpy = DefaultXDisplay();
        1270                 : #  ifdef MOZ_WIDGET_GTK2
        1271                 :         // GDK attempts to (asynchronously) track whether there is an active
        1272                 :         // grab so ungrab through GDK.
        1273               0 :         gdk_pointer_ungrab(npevent->xbutton.time);
        1274                 : #  else
        1275                 :         XUngrabPointer(dpy, npevent->xbutton.time);
        1276                 : #  endif
        1277                 :         // Wait for the ungrab to complete.
        1278               0 :         XSync(dpy, False);
        1279               0 :         break;
        1280                 :     }
        1281                 : #endif
        1282                 :
        1283                 : #ifdef XP_MACOSX
        1284                 :     if (npevent->type == NPCocoaEventDrawRect) {
        1285                 :         if (mDrawingModel == NPDrawingModelCoreAnimation ||
        1286                 :             mDrawingModel == NPDrawingModelInvalidatingCoreAnimation) {
        1287                 :             if (!mIOSurface) {
        1288                 :                 NS_ERROR("No IOSurface allocated.");
        1289                 :                 return false;
        1290                 :             }
        1291                 :             if (!CallNPP_HandleEvent_IOSurface(npremoteevent,
        1292                 :                                                mIOSurface->GetIOSurfaceID(),
        1293                 :                                                &handled))
        1294                 :                 return false; // no good way to handle errors here...
        1295                 :
        1296                 :             CGContextRef cgContext = npevent->data.draw.context;
        1297                 :             if (!mShColorSpace) {
        1298                 :                 mShColorSpace = CreateSystemColorSpace();
        1299                 :             }
        1300                 :             if (!mShColorSpace) {
        1301                 :                 PLUGIN_LOG_DEBUG(("Could not allocate ColorSpace."));
        1302                 :                 return false;
        1303                 :             }
        1304                 :             if (cgContext) {
        1305                 :                 nsCARenderer::DrawSurfaceToCGContext(cgContext, mIOSurface,
        1306                 :                                                      mShColorSpace,
        1307                 :                                                      npevent->data.draw.x,
        1308                 :                                                      npevent->data.draw.y,
        1309                 :                                                      npevent->data.draw.width,
        1310                 :                                                      npevent->data.draw.height);
        1311                 :             }
        1312                 :             return true;
        1313                 :         } else if (mFrontIOSurface) {
        1314                 :             CGContextRef cgContext = npevent->data.draw.context;
        1315                 :             if (!mShColorSpace) {
        1316                 :                 mShColorSpace = CreateSystemColorSpace();
        1317                 :             }
        1318                 :             if (!mShColorSpace) {
        1319                 :                 PLUGIN_LOG_DEBUG(("Could not allocate ColorSpace."));
        1320                 :                 return false;
        1321                 :             }
        1322                 :             if (cgContext) {
        1323                 :                 nsCARenderer::DrawSurfaceToCGContext(cgContext, mFrontIOSurface,
        1324                 :                                                      mShColorSpace,
        1325                 :                                                      npevent->data.draw.x,
        1326                 :                                                      npevent->data.draw.y,
        1327                 :                                                      npevent->data.draw.width,
        1328                 :                                                      npevent->data.draw.height);
        1329                 :             }
        1330                 :             return true;
        1331                 :         } else {
        1332                 :             if (mShWidth == 0 && mShHeight == 0) {
        1333                 :                 PLUGIN_LOG_DEBUG(("NPCocoaEventDrawRect on window of size 0."));
        1334                 :                 return false;
        1335                 :             }
        1336                 :             if (!mShSurface.IsReadable()) {
        1337                 :                 PLUGIN_LOG_DEBUG(("Shmem is not readable."));
        1338                 :                 return false;
        1339                 :             }
        1340                 :
        1341                 :             if (!CallNPP_HandleEvent_Shmem(npremoteevent, mShSurface,
        1342                 :                                            &handled, &mShSurface))
        1343                 :                 return false; // no good way to handle errors here...
        1344                 :
        1345                 :             if (!mShSurface.IsReadable()) {
        1346                 :                 PLUGIN_LOG_DEBUG(("Shmem not returned. Either the plugin crashed "
        1347                 :                                   "or we have a bug."));
        1348                 :                 return false;
        1349                 :             }
        1350                 :
        1351                 :             char* shContextByte = mShSurface.get<char>();
        1352                 :
        1353                 :             if (!mShColorSpace) {
        1354                 :                 mShColorSpace = CreateSystemColorSpace();
        1355                 :             }
        1356                 :             if (!mShColorSpace) {
        1357                 :                 PLUGIN_LOG_DEBUG(("Could not allocate ColorSpace."));
        1358                 :                 return false;
        1359                 :             }
        1360                 :             CGContextRef shContext = ::CGBitmapContextCreate(shContextByte,
        1361                 :                                     mShWidth, mShHeight, 8,
        1362                 :                                     mShWidth*4, mShColorSpace,
        1363                 :                                     kCGImageAlphaPremultipliedFirst |
        1364                 :                                     kCGBitmapByteOrder32Host);
        1365                 :             if (!shContext) {
        1366                 :                 PLUGIN_LOG_DEBUG(("Could not allocate CGBitmapContext."));
        1367                 :                 return false;
        1368                 :             }
        1369                 :
        1370                 :             CGImageRef shImage = ::CGBitmapContextCreateImage(shContext);
        1371                 :             if (shImage) {
        1372                 :                 CGContextRef cgContext = npevent->data.draw.context;
        1373                 :
        1374                 :                 ::CGContextDrawImage(cgContext,
        1375                 :                                      CGRectMake(0,0,mShWidth,mShHeight),
        1376                 :                                      shImage);
        1377                 :                 ::CGImageRelease(shImage);
        1378                 :             } else {
        1379                 :                 ::CGContextRelease(shContext);
        1380                 :                 return false;
        1381                 :             }
        1382                 :             ::CGContextRelease(shContext);
        1383                 :             return true;
        1384                 :         }
        1385                 :     }
        1386                 : #endif
        1387                 :
        1388               0 :     if (!CallNPP_HandleEvent(npremoteevent, &handled))
        1389               0 :         return 0; // no good way to handle errors here...
        1390                 :
        1391               0 :     return handled;
        1392                 : }
        1393                 :
        1394                 : NPError
        1395               0 : PluginInstanceParent::NPP_NewStream(NPMIMEType type, NPStream* stream,
        1396                 :                                     NPBool seekable, uint16_t* stype)
        1397                 : {
        1398               0 :     PLUGIN_LOG_DEBUG(("%s (type=%s, stream=%p, seekable=%i)",
        1399                 :                       FULLFUNCTION, (char*) type, (void*) stream, (int) seekable));
        1400                 :
        1401               0 :     BrowserStreamParent* bs = new BrowserStreamParent(this, stream);
        1402                 :
        1403                 :     NPError err;
        1404               0 :     if (!CallPBrowserStreamConstructor(bs,
        1405               0 :                                        NullableString(stream->url),
        1406                 :                                        stream->end,
        1407                 :                                        stream->lastmodified,
        1408                 :                                        static_cast<PStreamNotifyParent*>(stream->notifyData),
        1409               0 :                                        NullableString(stream->headers),
        1410               0 :                                        NullableString(type), seekable,
        1411               0 :                                        &err, stype))
        1412               0 :         return NPERR_GENERIC_ERROR;
        1413                 :
        1414               0 :     if (NPERR_NO_ERROR != err)
        1415               0 :         unused << PBrowserStreamParent::Send__delete__(bs);
        1416                 :
        1417               0 :     return err;
        1418                 : }
        1419                 :
        1420                 : NPError
        1421               0 : PluginInstanceParent::NPP_DestroyStream(NPStream* stream, NPReason reason)
        1422                 : {
        1423               0 :     PLUGIN_LOG_DEBUG(("%s (stream=%p, reason=%i)",
        1424                 :                       FULLFUNCTION, (void*) stream, (int) reason));
        1425                 :
        1426               0 :     AStream* s = static_cast<AStream*>(stream->pdata);
        1427               0 :     if (s->IsBrowserStream()) {
        1428                 :         BrowserStreamParent* sp =
        1429               0 :             static_cast<BrowserStreamParent*>(s);
        1430               0 :         if (sp->mNPP != this)
        1431               0 :             NS_RUNTIMEABORT("Mismatched plugin data");
        1432                 :
        1433               0 :         sp->NPP_DestroyStream(reason);
        1434               0 :         return NPERR_NO_ERROR;
        1435                 :     }
        1436                 :     else {
        1437                 :         PluginStreamParent* sp =
        1438               0 :             static_cast<PluginStreamParent*>(s);
        1439               0 :         if (sp->mInstance != this)
        1440               0 :             NS_RUNTIMEABORT("Mismatched plugin data");
        1441                 :
        1442               0 :         return PPluginStreamParent::Call__delete__(sp, reason, false) ?
        1443               0 :             NPERR_NO_ERROR : NPERR_GENERIC_ERROR;
        1444                 :     }
        1445                 : }
        1446                 :
        1447                 : void
        1448               0 : PluginInstanceParent::NPP_Print(NPPrint* platformPrint)
        1449                 : {
        1450                 :     // TODO: implement me
        1451               0 :     NS_ERROR("Not implemented");
        1452               0 : }
        1453                 :
        1454                 : PPluginScriptableObjectParent*
        1455               0 : PluginInstanceParent::AllocPPluginScriptableObject()
        1456                 : {
        1457               0 :     return new PluginScriptableObjectParent(Proxy);
        1458                 : }
        1459                 :
        1460                 : #ifdef DEBUG
        1461                 : namespace {
        1462                 :
        1463                 : struct ActorSearchData
        1464                 : {
        1465                 :     PluginScriptableObjectParent* actor;
        1466                 :     bool found;
        1467                 : };
        1468                 :
        1469                 : PLDHashOperator
        1470               0 : ActorSearch(const void* aKey,
        1471                 :             PluginScriptableObjectParent* aData,
        1472                 :             void* aUserData)
        1473                 : {
        1474               0 :     ActorSearchData* asd = reinterpret_cast<ActorSearchData*>(aUserData);
        1475               0 :     if (asd->actor == aData) {
        1476               0 :         asd->found = true;
        1477               0 :         return PL_DHASH_STOP;
        1478                 :     }
        1479               0 :     return PL_DHASH_NEXT;
        1480                 : }
        1481                 :
        1482                 : } // anonymous namespace
        1483                 : #endif // DEBUG
        1484                 :
        1485                 : bool
        1486               0 : PluginInstanceParent::DeallocPPluginScriptableObject(
        1487                 :                                          PPluginScriptableObjectParent* aObject)
        1488                 : {
        1489                 :     PluginScriptableObjectParent* actor =
        1490               0 :         static_cast<PluginScriptableObjectParent*>(aObject);
        1491                 :
        1492               0 :     NPObject* object = actor->GetObject(false);
        1493               0 :     if (object) {
        1494               0 :         NS_ASSERTION(mScriptableObjects.Get(object, nsnull),
        1495                 :                      "NPObject not in the hash!");
        1496               0 :         mScriptableObjects.Remove(object);
        1497                 :     }
        1498                 : #ifdef DEBUG
        1499                 :     else {
        1500               0 :         ActorSearchData asd = { actor, false };
        1501               0 :         mScriptableObjects.EnumerateRead(ActorSearch, &asd);
        1502               0 :         NS_ASSERTION(!asd.found, "Actor in the hash with a null NPObject!");
        1503                 :     }
        1504                 : #endif
        1505                 :
        1506               0 :     delete actor;
        1507               0 :     return true;
        1508                 : }
        1509                 :
        1510                 : bool
        1511               0 : PluginInstanceParent::RecvPPluginScriptableObjectConstructor(
        1512                 :                                           PPluginScriptableObjectParent* aActor)
        1513                 : {
        1514                 :     // This is only called in response to the child process requesting the
        1515                 :     // creation of an actor. This actor will represent an NPObject that is
        1516                 :     // created by the plugin and returned to the browser.
        1517                 :     PluginScriptableObjectParent* actor =
        1518               0 :         static_cast<PluginScriptableObjectParent*>(aActor);
        1519               0 :     NS_ASSERTION(!actor->GetObject(false), "Actor already has an object?!");
        1520                 :
        1521               0 :     actor->InitializeProxy();
        1522               0 :     NS_ASSERTION(actor->GetObject(false), "Actor should have an object!");
        1523                 :
        1524               0 :     return true;
        1525                 : }
        1526                 :
        1527                 : void
        1528               0 : PluginInstanceParent::NPP_URLNotify(const char* url, NPReason reason,
        1529                 :                                     void* notifyData)
        1530                 : {
        1531               0 :     PLUGIN_LOG_DEBUG(("%s (%s, %i, %p)",
        1532                 :                       FULLFUNCTION, url, (int) reason, notifyData));
        1533                 :
        1534                 :     PStreamNotifyParent* streamNotify =
        1535               0 :         static_cast<PStreamNotifyParent*>(notifyData);
        1536               0 :     unused << PStreamNotifyParent::Send__delete__(streamNotify, reason);
        1537               0 : }
        1538                 :
        1539                 : bool
        1540               0 : PluginInstanceParent::RegisterNPObjectForActor(
        1541                 :                                            NPObject* aObject,
        1542                 :                                            PluginScriptableObjectParent* aActor)
        1543                 : {
        1544               0 :     NS_ASSERTION(aObject && aActor, "Null pointers!");
        1545               0 :     NS_ASSERTION(mScriptableObjects.IsInitialized(), "Hash not initialized!");
        1546               0 :     NS_ASSERTION(!mScriptableObjects.Get(aObject, nsnull), "Duplicate entry!");
        1547               0 :     return !!mScriptableObjects.Put(aObject, aActor);
        1548                 : }
        1549                 :
        1550                 : void
        1551               0 : PluginInstanceParent::UnregisterNPObject(NPObject* aObject)
        1552                 : {
        1553               0 :     NS_ASSERTION(aObject, "Null pointer!");
        1554               0 :     NS_ASSERTION(mScriptableObjects.IsInitialized(), "Hash not initialized!");
        1555               0 :     NS_ASSERTION(mScriptableObjects.Get(aObject, nsnull), "Unknown entry!");
        1556               0 :     mScriptableObjects.Remove(aObject);
        1557               0 : }
        1558                 :
        1559                 : PluginScriptableObjectParent*
        1560               0 : PluginInstanceParent::GetActorForNPObject(NPObject* aObject)
        1561                 : {
        1562               0 :     NS_ASSERTION(aObject, "Null pointer!");
        1563                 :
        1564               0 :     if (aObject->_class == PluginScriptableObjectParent::GetClass()) {
        1565                 :         // One of ours!
        1566               0 :         ParentNPObject* object = static_cast<ParentNPObject*>(aObject);
        1567               0 :         NS_ASSERTION(object->parent, "Null actor!");
        1568               0 :         return object->parent;
        1569                 :     }
        1570                 :
        1571                 :     PluginScriptableObjectParent* actor;
        1572               0 :     if (mScriptableObjects.Get(aObject, &actor)) {
        1573               0 :         return actor;
        1574                 :     }
        1575                 :
        1576               0 :     actor = new PluginScriptableObjectParent(LocalObject);
        1577               0 :     if (!actor) {
        1578               0 :         NS_ERROR("Out of memory!");
        1579               0 :         return nsnull;
        1580                 :     }
        1581                 :
        1582               0 :     if (!SendPPluginScriptableObjectConstructor(actor)) {
        1583               0 :         NS_WARNING("Failed to send constructor message!");
        1584               0 :         return nsnull;
        1585                 :     }
        1586                 :
        1587               0 :     actor->InitializeLocal(aObject);
        1588               0 :     return actor;
        1589                 : }
        1590                 :
        1591                 : PPluginSurfaceParent*
        1592               0 : PluginInstanceParent::AllocPPluginSurface(const WindowsSharedMemoryHandle& handle,
        1593                 :                                           const gfxIntSize& size,
        1594                 :                                           const bool& transparent)
        1595                 : {
        1596                 : #ifdef XP_WIN
        1597                 :     return new PluginSurfaceParent(handle, size, transparent);
        1598                 : #else
        1599               0 :     NS_ERROR("This shouldn't be called!");
        1600               0 :     return NULL;
        1601                 : #endif
        1602                 : }
        1603                 :
        1604                 : bool
        1605               0 : PluginInstanceParent::DeallocPPluginSurface(PPluginSurfaceParent* s)
        1606                 : {
        1607                 : #ifdef XP_WIN
        1608                 :     delete s;
        1609                 :     return true;
        1610                 : #else
        1611               0 :     return false;
        1612                 : #endif
        1613                 : }
        1614                 :
        1615                 : bool
        1616               0 : PluginInstanceParent::AnswerNPN_PushPopupsEnabledState(const bool& aState)
        1617                 : {
        1618               0 :     mNPNIface->pushpopupsenabledstate(mNPP, aState ? 1 : 0);
        1619               0 :     return true;
        1620                 : }
        1621                 :
        1622                 : bool
        1623               0 : PluginInstanceParent::AnswerNPN_PopPopupsEnabledState()
        1624                 : {
        1625               0 :     mNPNIface->poppopupsenabledstate(mNPP);
        1626               0 :     return true;
        1627                 : }
        1628                 :
        1629                 : bool
        1630               0 : PluginInstanceParent::AnswerNPN_GetValueForURL(const NPNURLVariable& variable,
        1631                 :                                                const nsCString& url,
        1632                 :                                                nsCString* value,
        1633                 :                                                NPError* result)
        1634                 : {
        1635                 :     char* v;
        1636                 :     uint32_t len;
        1637                 :
        1638                 :     *result = mNPNIface->getvalueforurl(mNPP, (NPNURLVariable) variable,
        1639               0 :                                         url.get(), &v, &len);
        1640               0 :     if (NPERR_NO_ERROR == *result)
        1641               0 :         value->Adopt(v, len);
        1642                 :
        1643               0 :     return true;
        1644                 : }
        1645                 :
        1646                 : bool
        1647               0 : PluginInstanceParent::AnswerNPN_SetValueForURL(const NPNURLVariable& variable,
        1648                 :                                                const nsCString& url,
        1649                 :                                                const nsCString& value,
        1650                 :                                                NPError* result)
        1651                 : {
        1652                 :     *result = mNPNIface->setvalueforurl(mNPP, (NPNURLVariable) variable,
        1653                 :                                         url.get(), value.get(),
        1654               0 :                                         value.Length());
        1655               0 :     return true;
        1656                 : }
        1657                 :
        1658                 : bool
        1659               0 : PluginInstanceParent::AnswerNPN_GetAuthenticationInfo(const nsCString& protocol,
        1660                 :                                                       const nsCString& host,
        1661                 :                                                       const int32_t& port,
        1662                 :                                                       const nsCString& scheme,
        1663                 :                                                       const nsCString& realm,
        1664                 :                                                       nsCString* username,
        1665                 :                                                       nsCString* password,
        1666                 :                                                       NPError* result)
        1667                 : {
        1668                 :     char* u;
        1669                 :     uint32_t ulen;
        1670                 :     char* p;
        1671                 :     uint32_t plen;
        1672                 :
        1673                 :     *result = mNPNIface->getauthenticationinfo(mNPP, protocol.get(),
        1674                 :                                                host.get(), port,
        1675                 :                                                scheme.get(), realm.get(),
        1676               0 :                                                &u, &ulen, &p, &plen);
        1677               0 :     if (NPERR_NO_ERROR == *result) {
        1678               0 :         username->Adopt(u, ulen);
        1679               0 :         password->Adopt(p, plen);
        1680                 :     }
        1681               0 :     return true;
        1682                 : }
        1683                 :
        1684                 : bool
        1685               0 : PluginInstanceParent::AnswerNPN_ConvertPoint(const double& sourceX,
        1686                 :                                              const bool&   ignoreDestX,
        1687                 :                                              const double& sourceY,
        1688                 :                                              const bool&   ignoreDestY,
        1689                 :                                              const NPCoordinateSpace& sourceSpace,
        1690                 :                                              const NPCoordinateSpace& destSpace,
        1691                 :                                              double *destX,
        1692                 :                                              double *destY,
        1693                 :                                              bool *result)
        1694                 : {
        1695                 :     *result = mNPNIface->convertpoint(mNPP, sourceX, sourceY, sourceSpace,
        1696                 :                                       ignoreDestX ? nsnull : destX,
        1697                 :                                       ignoreDestY ? nsnull : destY,
        1698               0 :                                       destSpace);
        1699                 :
        1700               0 :     return true;
        1701                 : }
        1702                 :
        1703                 : bool
        1704               0 : PluginInstanceParent::AnswerNPN_InitAsyncSurface(const gfxIntSize& size,
        1705                 :                                                  const NPImageFormat& format,
        1706                 :                                                  NPRemoteAsyncSurface* surfData,
        1707                 :                                                  bool* result)
        1708                 : {
        1709               0 :     if (!IsAsyncDrawing()) {
        1710               0 :         *result = false;
        1711               0 :         return true;
        1712                 :     }
        1713                 :
        1714               0 :     switch (mDrawingModel) {
        1715                 :     case NPDrawingModelAsyncBitmapSurface: {
        1716               0 :             Shmem sharedMem;
        1717               0 :             if (!AllocUnsafeShmem(size.width * size.height * 4, SharedMemory::TYPE_BASIC, &sharedMem)) {
        1718               0 :                 *result = false;
        1719               0 :                 return true;
        1720                 :             }
        1721                 :
        1722               0 :             surfData->size() = size;
        1723               0 :             surfData->hostPtr() = (uintptr_t)sharedMem.get<unsigned char>();
        1724               0 :             surfData->stride() = size.width * 4;
        1725               0 :             surfData->format() = format;
        1726               0 :             surfData->data() = sharedMem;
        1727               0 :             *result = true;
        1728                 :         }
        1729                 :     }
        1730                 :
        1731               0 :     return true;
        1732                 : }
        1733                 :
        1734                 : bool
        1735               0 : PluginInstanceParent::RecvRedrawPlugin()
        1736                 : {
        1737               0 :     nsNPAPIPluginInstance *inst = static_cast<nsNPAPIPluginInstance*>(mNPP->ndata);
        1738               0 :     if (!inst) {
        1739               0 :         return false;
        1740                 :     }
        1741                 :
        1742               0 :     inst->RedrawPlugin();
        1743               0 :     return true;
        1744                 : }
        1745                 :
        1746                 : bool
        1747               0 : PluginInstanceParent::RecvNegotiatedCarbon()
        1748                 : {
        1749               0 :     nsNPAPIPluginInstance *inst = static_cast<nsNPAPIPluginInstance*>(mNPP->ndata);
        1750               0 :     if (!inst) {
        1751               0 :         return false;
        1752                 :     }
        1753               0 :     inst->CarbonNPAPIFailure();
        1754               0 :     return true;
        1755                 : }
        1756                 :
        1757                 : #if defined(OS_WIN)
        1758                 :
        1759                 : /*
        1760                 :   plugin focus changes between processes
        1761                 :
        1762                 :   focus from dom -> child:
        1763                 :     Focus manager calls on widget to set the focus on the window.
        1764                 :     We pick up the resulting wm_setfocus event here, and forward
        1765                 :     that over ipc to the child which calls set focus on itself.
        1766                 :
        1767                 :   focus from child -> focus manager:
        1768                 :     Child picks up the local wm_setfocus and sends it via ipc over
        1769                 :     here. We then post a custom event to widget/windows/nswindow
        1770                 :     which fires off a gui event letting the browser know.
        1771                 : */
        1772                 :
        1773                 : static const PRUnichar kPluginInstanceParentProperty[] =
        1774                 :                          L"PluginInstanceParentProperty";
        1775                 :
        1776                 : // static
        1777                 : LRESULT CALLBACK
        1778                 : PluginInstanceParent::PluginWindowHookProc(HWND hWnd,
        1779                 :                                            UINT message,
        1780                 :                                            WPARAM wParam,
        1781                 :                                            LPARAM lParam)
        1782                 : {
        1783                 :     PluginInstanceParent* self = reinterpret_cast<PluginInstanceParent*>(
        1784                 :         ::GetPropW(hWnd, kPluginInstanceParentProperty));
        1785                 :     if (!self) {
        1786                 :         NS_NOTREACHED("PluginInstanceParent::PluginWindowHookProc null this ptr!");
        1787                 :         return DefWindowProc(hWnd, message, wParam, lParam);
        1788                 :     }
        1789                 :
        1790                 :     NS_ASSERTION(self->mPluginHWND == hWnd, "Wrong window!");
        1791                 :
        1792                 :     switch (message) {
        1793                 :         case WM_SETFOCUS:
        1794                 :         // Let the child plugin window know it should take focus.
        1795                 :         self->CallSetPluginFocus();
        1796                 :         break;
        1797                 :
        1798                 :         case WM_CLOSE:
        1799                 :         self->UnsubclassPluginWindow();
        1800                 :         break;
        1801                 :     }
        1802                 :
        1803                 :     if (self->mPluginWndProc == PluginWindowHookProc) {
        1804                 :       NS_NOTREACHED(
        1805                 :         "PluginWindowHookProc invoking mPluginWndProc w/"
        1806                 :         "mPluginWndProc == PluginWindowHookProc????");
        1807                 :         return DefWindowProc(hWnd, message, wParam, lParam);
        1808                 :     }
        1809                 :     return ::CallWindowProc(self->mPluginWndProc, hWnd, message, wParam,
        1810                 :                             lParam);
        1811                 : }
        1812                 :
        1813                 : void
        1814                 : PluginInstanceParent::SubclassPluginWindow(HWND aWnd)
        1815                 : {
        1816                 :     NS_ASSERTION(!(mPluginHWND && aWnd != mPluginHWND),
        1817                 :       "PluginInstanceParent::SubclassPluginWindow hwnd is not our window!");
        1818                 :
        1819                 :     if (!mPluginHWND) {
        1820                 :         mPluginHWND = aWnd;
        1821                 :         mPluginWndProc =
        1822                 :             (WNDPROC)::SetWindowLongPtrA(mPluginHWND, GWLP_WNDPROC,
        1823                 :                          reinterpret_cast<LONG_PTR>(PluginWindowHookProc));
        1824                 :         bool bRes = ::SetPropW(mPluginHWND, kPluginInstanceParentProperty, this);
        1825                 :         NS_ASSERTION(mPluginWndProc,
        1826                 :           "PluginInstanceParent::SubclassPluginWindow failed to set subclass!");
        1827                 :         NS_ASSERTION(bRes,
        1828                 :           "PluginInstanceParent::SubclassPluginWindow failed to set prop!");
        1829                 :    }
        1830                 : }
        1831                 :
        1832                 : void
        1833                 : PluginInstanceParent::UnsubclassPluginWindow()
        1834                 : {
        1835                 :     if (mPluginHWND && mPluginWndProc) {
        1836                 :         ::SetWindowLongPtrA(mPluginHWND, GWLP_WNDPROC,
        1837                 :                             reinterpret_cast<LONG_PTR>(mPluginWndProc));
        1838                 :
        1839                 :         ::RemovePropW(mPluginHWND, kPluginInstanceParentProperty);
        1840                 :
        1841                 :         mPluginWndProc = NULL;
        1842                 :         mPluginHWND = NULL;
        1843                 :     }
        1844                 : }
        1845                 :
        1846                 : /* windowless drawing helpers */
        1847                 :
        1848                 : /*
        1849                 :  * Origin info:
        1850                 :  *
        1851                 :  * windowless, offscreen:
        1852                 :  *
        1853                 :  * WM_WINDOWPOSCHANGED: origin is relative to container
        1854                 :  * setwindow: origin is 0,0
        1855                 :  * WM_PAINT: origin is 0,0
        1856                 :  *
        1857                 :  * windowless, native:
        1858                 :  *
        1859                 :  * WM_WINDOWPOSCHANGED: origin is relative to container
        1860                 :  * setwindow: origin is relative to container
        1861                 :  * WM_PAINT: origin is relative to container
        1862                 :  *
        1863                 :  * PluginInstanceParent:
        1864                 :  *
        1865                 :  * painting: mPluginPort (nsIntRect, saved in SetWindow)
        1866                 :  */
        1867                 :
        1868                 : void
        1869                 : PluginInstanceParent::SharedSurfaceRelease()
        1870                 : {
        1871                 :     mSharedSurfaceDib.Close();
        1872                 : }
        1873                 :
        1874                 : bool
        1875                 : PluginInstanceParent::SharedSurfaceSetWindow(const NPWindow* aWindow,
        1876                 :                                              NPRemoteWindow& aRemoteWindow)
        1877                 : {
        1878                 :     aRemoteWindow.window = nsnull;
        1879                 :     aRemoteWindow.x      = aWindow->x;
        1880                 :     aRemoteWindow.y      = aWindow->y;
        1881                 :     aRemoteWindow.width  = aWindow->width;
        1882                 :     aRemoteWindow.height = aWindow->height;
        1883                 :     aRemoteWindow.type   = aWindow->type;
        1884                 :
        1885                 :     nsIntRect newPort(aWindow->x, aWindow->y, aWindow->width, aWindow->height);
        1886                 :
        1887                 :     // save the the rect location within the browser window.
        1888                 :     mPluginPort = newPort;
        1889                 :
        1890                 :     // move the port to our shared surface origin
        1891                 :     newPort.MoveTo(0,0);
        1892                 :
        1893                 :     // check to see if we have the room in shared surface
        1894                 :     if (mSharedSurfaceDib.IsValid() && mSharedSize.Contains(newPort)) {
        1895                 :       // ok to paint
        1896                 :       aRemoteWindow.surfaceHandle = 0;
        1897                 :       return true;
        1898                 :     }
        1899                 :
        1900                 :     // allocate a new shared surface
        1901                 :     SharedSurfaceRelease();
        1902                 :     if (NS_FAILED(mSharedSurfaceDib.Create(reinterpret_cast<HDC>(aWindow->window),
        1903                 :                                            newPort.width, newPort.height, false)))
        1904                 :       return false;
        1905                 :
        1906                 :     // save the new shared surface size we just allocated
        1907                 :     mSharedSize = newPort;
        1908                 :
        1909                 :     base::SharedMemoryHandle handle;
        1910                 :     if (NS_FAILED(mSharedSurfaceDib.ShareToProcess(mParent->ChildProcessHandle(), &handle)))
        1911                 :       return false;
        1912                 :
        1913                 :     aRemoteWindow.surfaceHandle = handle;
        1914                 :
        1915                 :     return true;
        1916                 : }
        1917                 :
        1918                 : void
        1919                 : PluginInstanceParent::SharedSurfaceBeforePaint(RECT& rect,
        1920                 :                                                NPRemoteEvent& npremoteevent)
        1921                 : {
        1922                 :     RECT* dr = (RECT*)npremoteevent.event.lParam;
        1923                 :     HDC parentHdc = (HDC)npremoteevent.event.wParam;
        1924                 :
        1925                 :     nsIntRect dirtyRect(dr->left, dr->top, dr->right-dr->left, dr->bottom-dr->top);
        1926                 :     dirtyRect.MoveBy(-mPluginPort.x, -mPluginPort.y); // should always be smaller than dirtyRect
        1927                 :
        1928                 :     ::BitBlt(mSharedSurfaceDib.GetHDC(),
        1929                 :              dirtyRect.x,
        1930                 :              dirtyRect.y,
        1931                 :              dirtyRect.width,
        1932                 :              dirtyRect.height,
        1933                 :              parentHdc,
        1934                 :              dr->left,
        1935                 :              dr->top,
        1936                 :              SRCCOPY);
        1937                 :
        1938                 :     // setup the translated dirty rect we'll send to the child
        1939                 :     rect.left   = dirtyRect.x;
        1940                 :     rect.top    = dirtyRect.y;
        1941                 :     rect.right  = dirtyRect.x + dirtyRect.width;
        1942                 :     rect.bottom = dirtyRect.y + dirtyRect.height;
        1943                 :
        1944                 :     npremoteevent.event.wParam = WPARAM(0);
        1945                 :     npremoteevent.event.lParam = LPARAM(&rect);
        1946                 : }
        1947                 :
        1948                 : void
        1949                 : PluginInstanceParent::SharedSurfaceAfterPaint(NPEvent* npevent)
        1950                 : {
        1951                 :     RECT* dr = (RECT*)npevent->lParam;
        1952                 :     HDC parentHdc = (HDC)npevent->wParam;
        1953                 :
        1954                 :     nsIntRect dirtyRect(dr->left, dr->top, dr->right-dr->left, dr->bottom-dr->top);
        1955                 :     dirtyRect.MoveBy(-mPluginPort.x, -mPluginPort.y);
        1956                 :
        1957                 :     // src copy the shared dib into the parent surface we are handed.
        1958                 :     ::BitBlt(parentHdc,
        1959                 :              dr->left,
        1960                 :              dr->top,
        1961                 :              dirtyRect.width,
        1962                 :              dirtyRect.height,
        1963                 :              mSharedSurfaceDib.GetHDC(),
        1964                 :              dirtyRect.x,
        1965                 :              dirtyRect.y,
        1966                 :              SRCCOPY);
        1967                 : }
        1968                 :
        1969                 : #endif // defined(OS_WIN)
        1970                 :
        1971                 : bool
        1972               0 : PluginInstanceParent::AnswerPluginFocusChange(const bool& gotFocus)
        1973                 : {
        1974               0 :     PLUGIN_LOG_DEBUG(("%s", FULLFUNCTION));
        1975                 :
        1976                 :     // Currently only in use on windows - an rpc event we receive from the
        1977                 :     // child when it's plugin window (or one of it's children) receives keyboard
        1978                 :     // focus. We forward the event down to widget so the dom/focus manager can
        1979                 :     // be updated.
        1980                 : #if defined(OS_WIN)
        1981                 :     ::SendMessage(mPluginHWND, gOOPPPluginFocusEvent, gotFocus ? 1 : 0, 0);
        1982                 :     return true;
        1983                 : #else
        1984               0 :     NS_NOTREACHED("PluginInstanceParent::AnswerPluginFocusChange not implemented!");
        1985               0 :     return false;
        1986                 : #endif
        1987                 : }

Generated by: LCOV version 1.7