LCOV - app.info - dom/plugins/base/nsPluginInstanceOwner.h

LCOV - code coverage report
| Current view: | directory - dom/plugins/base - nsPluginInstanceOwner.h (source / functions) |  | Found | Hit | Coverage |
| Test: | app.info | Lines: | 22 | 0 | 0.0 %
| Date: | 2012-04-21 | Functions: | 5 | 0 | 0.0 %

           1                 : /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
           2                 : // vim:set ts=2 sts=2 sw=2 et cin:
           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 Communicator client code.
          17                 :  *
          18                 :  * The Initial Developer of the Original Code is
          19                 :  * Netscape Communications Corporation.
          20                 :  * Portions created by the Initial Developer are Copyright (C) 1998
          21                 :  * the Initial Developer. All Rights Reserved.
          22                 :  *
          23                 :  * Contributor(s):
          24                 :  *   Pierre Phaneuf <pp@ludusdesign.com>
          25                 :  *   Jacek Piskozub <piskozub@iopan.gda.pl>
          26                 :  *   Leon Sha <leon.sha@sun.com>
          27                 :  *   Roland Mainz <roland.mainz@informatik.med.uni-giessen.de>
          28                 :  *   Robert O'Callahan <roc+moz@cs.cmu.edu>
          29                 :  *   Christian Biesinger <cbiesinger@web.de>
          30                 :  *   Josh Aas <josh@mozilla.com>
          31                 :  *   Mats Palmgren <matspal@gmail.com>
          32                 :  *
          33                 :  * Alternatively, the contents of this file may be used under the terms of
          34                 :  * either of the GNU General Public License Version 2 or later (the "GPL"),
          35                 :  * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
          36                 :  * in which case the provisions of the GPL or the LGPL are applicable instead
          37                 :  * of those above. If you wish to allow use of your version of this file only
          38                 :  * under the terms of either the GPL or the LGPL, and not to allow others to
          39                 :  * use your version of this file under the terms of the MPL, indicate your
          40                 :  * decision by deleting the provisions above and replace them with the notice
          41                 :  * and other provisions required by the GPL or the LGPL. If you do not delete
          42                 :  * the provisions above, a recipient may use your version of this file under
          43                 :  * the terms of any one of the MPL, the GPL or the LGPL.
          44                 :  *
          45                 :  * ***** END LICENSE BLOCK ***** */
          46                 :
          47                 : #ifndef nsPluginInstanceOwner_h_
          48                 : #define nsPluginInstanceOwner_h_
          49                 :
          50                 : #include "prtypes.h"
          51                 : #include "npapi.h"
          52                 : #include "nsCOMPtr.h"
          53                 : #include "nsIPluginInstanceOwner.h"
          54                 : #include "nsIPluginTagInfo.h"
          55                 : #include "nsIDOMEventListener.h"
          56                 : #include "nsIScrollPositionListener.h"
          57                 : #include "nsPluginHost.h"
          58                 : #include "nsPluginNativeWindow.h"
          59                 : #include "gfxRect.h"
          60                 :
          61                 : // X.h defines KeyPress
          62                 : #ifdef KeyPress
          63                 : #undef KeyPress
          64                 : #endif
          65                 :
          66                 : #ifdef XP_MACOSX
          67                 : #include "nsCoreAnimationSupport.h"
          68                 : #include <ApplicationServices/ApplicationServices.h>
          69                 : #endif
          70                 :
          71                 : class nsIInputStream;
          72                 : struct nsIntRect;
          73                 : class nsPluginDOMContextMenuListener;
          74                 : class nsObjectFrame;
          75                 : class nsDisplayListBuilder;
          76                 :
          77                 : #ifdef MOZ_X11
          78                 : class gfxXlibSurface;
          79                 : #endif
          80                 :
          81                 : #ifdef MOZ_WIDGET_GTK2
          82                 : #include "gfxXlibNativeRenderer.h"
          83                 : #endif
          84                 :
          85                 : #ifdef MOZ_WIDGET_QT
          86                 : #ifdef MOZ_X11
          87                 : #include "gfxQtNativeRenderer.h"
          88                 : #endif
          89                 : #endif
          90                 :
          91                 : #ifdef XP_OS2
          92                 : #define INCL_PM
          93                 : #define INCL_GPI
          94                 : #include <os2.h>
          95                 : #endif
          96                 :
          97                 : #ifdef MOZ_WIDGET_ANDROID
          98                 : namespace mozilla {
          99                 :   class AndroidMediaLayer;
         100                 : }
         101                 : #endif
         102                 :
         103                 : // X.h defines KeyPress
         104                 : #ifdef KeyPress
         105                 : #undef KeyPress
         106                 : #endif
         107                 :
         108                 : class nsPluginInstanceOwner : public nsIPluginInstanceOwner,
         109                 :                               public nsIPluginTagInfo,
         110                 :                               public nsIDOMEventListener,
         111                 :                               public nsIScrollPositionListener
         112                 : {
         113                 : public:
         114                 :   nsPluginInstanceOwner();
         115                 :   virtual ~nsPluginInstanceOwner();
         116                 :
         117                 :   NS_DECL_ISUPPORTS
         118                 :   NS_DECL_NSIPLUGININSTANCEOWNER
         119                 :
         120                 :   NS_IMETHOD GetURL(const char *aURL, const char *aTarget,
         121                 :                     nsIInputStream *aPostStream,
         122                 :                     void *aHeadersData, PRUint32 aHeadersDataLen);
         123                 :
         124                 :   NS_IMETHOD ShowStatus(const PRUnichar *aStatusMsg);
         125                 :
         126                 :   NPError    ShowNativeContextMenu(NPMenu* menu, void* event);
         127                 :
         128                 :   NPBool     ConvertPoint(double sourceX, double sourceY, NPCoordinateSpace sourceSpace,
         129                 :                           double *destX, double *destY, NPCoordinateSpace destSpace);
         130                 :
         131                 :   virtual NPError InitAsyncSurface(NPSize *size, NPImageFormat format,
         132                 :                                    void *initData, NPAsyncSurface *surface);
         133                 :   virtual NPError FinalizeAsyncSurface(NPAsyncSurface *surface);
         134                 :   virtual void SetCurrentAsyncSurface(NPAsyncSurface *surface, NPRect *changed);
         135                 :
         136                 :   //nsIPluginTagInfo interface
         137                 :   NS_DECL_NSIPLUGINTAGINFO
         138                 :
         139                 :   // nsIDOMEventListener interfaces
         140                 :   NS_DECL_NSIDOMEVENTLISTENER
         141                 :
         142                 :   nsresult MouseDown(nsIDOMEvent* aKeyEvent);
         143                 :   nsresult KeyPress(nsIDOMEvent* aKeyEvent);
         144                 : #if defined(MOZ_WIDGET_QT) && (MOZ_PLATFORM_MAEMO == 6)
         145                 :   nsresult Text(nsIDOMEvent* aTextEvent);
         146                 : #endif
         147                 :
         148                 :   nsresult Destroy();
         149                 :
         150                 : #ifdef XP_WIN
         151                 :   void Paint(const RECT& aDirty, HDC aDC);
         152                 : #elif defined(XP_MACOSX)
         153                 :   void Paint(const gfxRect& aDirtyRect, CGContextRef cgContext);
         154                 :   void RenderCoreAnimation(CGContextRef aCGContext, int aWidth, int aHeight);
         155                 :   void DoCocoaEventDrawRect(const gfxRect& aDrawRect, CGContextRef cgContext);
         156                 : #elif defined(MOZ_X11) || defined(ANDROID)
         157                 :   void Paint(gfxContext* aContext,
         158                 :              const gfxRect& aFrameRect,
         159                 :              const gfxRect& aDirtyRect);
         160                 : #elif defined(XP_OS2)
         161                 :   void Paint(const nsRect& aDirtyRect, HPS aHPS);
         162                 : #endif
         163                 :
         164                 : #ifdef MAC_CARBON_PLUGINS
         165                 :   void CancelTimer();
         166                 :   void StartTimer(bool isVisible);
         167                 : #endif
         168                 :   void SendIdleEvent();
         169                 :
         170                 :   // nsIScrollPositionListener interface
         171                 :   virtual void ScrollPositionWillChange(nscoord aX, nscoord aY);
         172                 :   virtual void ScrollPositionDidChange(nscoord aX, nscoord aY);
         173                 :
         174                 :   //locals
         175                 :
         176                 :   nsresult Init(nsIContent* aContent);
         177                 :
         178                 :   void* GetPluginPortFromWidget();
         179                 :   void ReleasePluginPort(void* pluginPort);
         180                 :
         181                 :   nsEventStatus ProcessEvent(const nsGUIEvent & anEvent);
         182                 :
         183                 : #ifdef XP_MACOSX
         184                 :   enum { ePluginPaintEnable, ePluginPaintDisable };
         185                 :
         186                 :   NPDrawingModel GetDrawingModel();
         187                 :   bool IsRemoteDrawingCoreAnimation();
         188                 :   NPEventModel GetEventModel();
         189                 :   static void CARefresh(nsITimer *aTimer, void *aClosure);
         190                 :   void AddToCARefreshTimer();
         191                 :   void RemoveFromCARefreshTimer();
         192                 :   // This calls into the plugin (NPP_SetWindow) and can run script.
         193                 :   void* FixUpPluginWindow(PRInt32 inPaintState);
         194                 :   void HidePluginWindow();
         195                 :   // Set a flag that (if true) indicates the plugin port info has changed and
         196                 :   // SetWindow() needs to be called.
         197                 :   void SetPluginPortChanged(bool aState) { mPluginPortChanged = aState; }
         198                 :   // Return a pointer to the internal nsPluginPort structure that's used to
         199                 :   // store a copy of plugin port info and to detect when it's been changed.
         200                 :   void* GetPluginPortCopy();
         201                 :   // Set plugin port info in the plugin (in the 'window' member of the
         202                 :   // NPWindow structure passed to the plugin by SetWindow()) and set a
         203                 :   // flag (mPluginPortChanged) to indicate whether or not this info has
         204                 :   // changed, and SetWindow() needs to be called again.
         205                 :   void* SetPluginPortAndDetectChange();
         206                 :   // Flag when we've set up a Thebes (and CoreGraphics) context in
         207                 :   // nsObjectFrame::PaintPlugin().  We need to know this in
         208                 :   // FixUpPluginWindow() (i.e. we need to know when FixUpPluginWindow() has
         209                 :   // been called from nsObjectFrame::PaintPlugin() when we're using the
         210                 :   // CoreGraphics drawing model).
         211                 :   void BeginCGPaint();
         212                 :   void EndCGPaint();
         213                 : #else // XP_MACOSX
         214                 :   void UpdateWindowPositionAndClipRect(bool aSetWindow);
         215                 :   void UpdateWindowVisibility(bool aVisible);
         216                 :   void UpdateDocumentActiveState(bool aIsActive);
         217                 : #endif // XP_MACOSX
         218                 :
         219                 :   void SetFrame(nsObjectFrame *aFrame);
         220                 :   nsObjectFrame* GetFrame();
         221                 :
         222                 :   PRUint32 GetLastEventloopNestingLevel() const {
         223                 :     return mLastEventloopNestingLevel;
         224                 :   }
         225                 :
         226                 :   static PRUint32 GetEventloopNestingLevel();
         227                 :
         228               0 :   void ConsiderNewEventloopNestingLevel() {
         229               0 :     PRUint32 currentLevel = GetEventloopNestingLevel();
         230                 :
         231               0 :     if (currentLevel < mLastEventloopNestingLevel) {
         232               0 :       mLastEventloopNestingLevel = currentLevel;
         233                 :     }
         234               0 :   }
         235                 :
         236                 :   const char* GetPluginName()
         237                 :   {
         238                 :     if (mInstance && mPluginHost) {
         239                 :       const char* name = NULL;
         240                 :       if (NS_SUCCEEDED(mPluginHost->GetPluginName(mInstance, &name)) && name)
         241                 :         return name;
         242                 :     }
         243                 :     return "";
         244                 :   }
         245                 :
         246                 : #ifdef MOZ_X11
         247               0 :   void GetPluginDescription(nsACString& aDescription)
         248                 :   {
         249               0 :     aDescription.Truncate();
         250               0 :     if (mInstance && mPluginHost) {
         251               0 :       nsCOMPtr<nsIPluginTag> pluginTag;
         252                 :
         253                 :       mPluginHost->GetPluginTagForInstance(mInstance,
         254               0 :                                            getter_AddRefs(pluginTag));
         255               0 :       if (pluginTag) {
         256               0 :         pluginTag->GetDescription(aDescription);
         257                 :       }
         258                 :     }
         259               0 :   }
         260                 : #endif
         261                 :
         262               0 :   bool SendNativeEvents()
         263                 :   {
         264                 : #ifdef XP_WIN
         265                 :     // XXX we should remove the plugin name check
         266                 :     return mPluginWindow->type == NPWindowTypeDrawable &&
         267                 :     (MatchPluginName("Shockwave Flash") ||
         268                 :      MatchPluginName("Test Plug-in"));
         269                 : #elif defined(MOZ_X11) || defined(XP_MACOSX)
         270               0 :     return true;
         271                 : #else
         272                 :     return false;
         273                 : #endif
         274                 :   }
         275                 :
         276                 :   bool MatchPluginName(const char *aPluginName)
         277                 :   {
         278                 :     return strncmp(GetPluginName(), aPluginName, strlen(aPluginName)) == 0;
         279                 :   }
         280                 :
         281                 :   void NotifyPaintWaiter(nsDisplayListBuilder* aBuilder);
         282                 :
         283                 :   // Returns the image container that has our currently displayed image.
         284                 :   already_AddRefed<ImageContainer> GetImageContainer();
         285                 :
         286                 :   /**
         287                 :    * Returns the bounds of the current async-rendered surface. This can only
         288                 :    * change in response to messages received by the event loop (i.e. not during
         289                 :    * painting).
         290                 :    */
         291                 :   nsIntSize GetCurrentImageSize();
         292                 :
         293                 :   // Methods to update the background image we send to async plugins.
         294                 :   // The eventual target of these operations is PluginInstanceParent,
         295                 :   // but it takes several hops to get there.
         296                 :   void SetBackgroundUnknown();
         297                 :   already_AddRefed<gfxContext> BeginUpdateBackground(const nsIntRect& aRect);
         298                 :   void EndUpdateBackground(gfxContext* aContext, const nsIntRect& aRect);
         299                 :
         300                 :   bool UseAsyncRendering();
         301                 :
         302                 : #ifdef MOZ_WIDGET_ANDROID
         303                 :   nsIntRect GetVisibleRect() {
         304                 :     return nsIntRect(0, 0, mPluginWindow->width, mPluginWindow->height);
         305                 :   }
         306                 :
         307                 :   void SetInverted(bool aInverted) {
         308                 :     mInverted = aInverted;
         309                 :   }
         310                 :
         311                 :   bool Inverted() {
         312                 :     return mInverted;
         313                 :   }
         314                 :
         315                 :   mozilla::AndroidMediaLayer* Layer() {
         316                 :     return mLayer;
         317                 :   }
         318                 :
         319                 :   void Invalidate();
         320                 : #endif
         321                 :
         322                 : private:
         323                 :
         324                 :   // return FALSE if LayerSurface dirty (newly created and don't have valid plugin content yet)
         325               0 :   bool IsUpToDate()
         326                 :   {
         327               0 :     nsIntSize size;
         328               0 :     return NS_SUCCEEDED(mInstance->GetImageSize(&size)) &&
         329               0 :     size == nsIntSize(mPluginWindow->width, mPluginWindow->height);
         330                 :   }
         331                 :
         332                 :   void FixUpURLS(const nsString &name, nsAString &value);
         333                 : #ifdef MOZ_WIDGET_ANDROID
         334                 :   void SendSize(int width, int height);
         335                 :
         336                 :   bool AddPluginView(const gfxRect& aRect);
         337                 :   void RemovePluginView();
         338                 :
         339                 :   bool mInverted;
         340                 :
         341                 :   // For kOpenGL_ANPDrawingModel
         342                 :   nsRefPtr<mozilla::AndroidMediaLayer> mLayer;
         343                 : #endif
         344                 :
         345                 :   nsPluginNativeWindow       *mPluginWindow;
         346                 :   nsRefPtr<nsNPAPIPluginInstance> mInstance;
         347                 :   nsObjectFrame              *mObjectFrame;
         348                 :   nsIContent                 *mContent; // WEAK, content owns us
         349                 :   nsCString                   mDocumentBase;
         350                 :   char                       *mTagText;
         351                 :   bool                        mWidgetCreationComplete;
         352                 :   nsCOMPtr<nsIWidget>         mWidget;
         353                 :   nsRefPtr<nsPluginHost>      mPluginHost;
         354                 :
         355                 : #ifdef XP_MACOSX
         356                 :   NP_CGContext                              mCGPluginPortCopy;
         357                 : #ifndef NP_NO_QUICKDRAW
         358                 :   NP_Port                                   mQDPluginPortCopy;
         359                 : #endif
         360                 :   PRInt32                                   mInCGPaintLevel;
         361                 :   nsRefPtr<nsIOSurface>                     mIOSurface;
         362                 :   nsCARenderer                              mCARenderer;
         363                 :   CGColorSpaceRef                           mColorProfile;
         364                 :   static nsCOMPtr<nsITimer>                *sCATimer;
         365                 :   static nsTArray<nsPluginInstanceOwner*>  *sCARefreshListeners;
         366                 :   bool                                      mSentInitialTopLevelWindowEvent;
         367                 : #endif
         368                 :   // We need to know if async hide window is required since we
         369                 :   // can not check UseAsyncRendering when executing StopPlugin
         370                 :   bool                                      mAsyncHidePluginWindow;
         371                 :
         372                 :   // Initially, the event loop nesting level we were created on, it's updated
         373                 :   // if we detect the appshell is on a lower level as long as we're not stopped.
         374                 :   // We delay DoStopPlugin() until the appshell reaches this level or lower.
         375                 :   PRUint32                    mLastEventloopNestingLevel;
         376                 :   bool                        mContentFocused;
         377                 :   bool                        mWidgetVisible;    // used on Mac to store our widget's visible state
         378                 : #ifdef XP_MACOSX
         379                 :   bool                        mPluginPortChanged;
         380                 : #endif
         381                 : #ifdef MOZ_X11
         382                 :   // Used with windowless plugins only, initialized in CreateWidget().
         383                 :   bool                        mFlash10Quirks;
         384                 : #endif
         385                 :   bool                        mPluginWindowVisible;
         386                 :   bool                        mPluginDocumentActiveState;
         387                 :
         388                 :   PRUint16          mNumCachedAttrs;
         389                 :   PRUint16          mNumCachedParams;
         390                 :   char              **mCachedAttrParamNames;
         391                 :   char              **mCachedAttrParamValues;
         392                 :
         393                 : #ifdef XP_MACOSX
         394                 :   NPEventModel mEventModel;
         395                 :   // This is a hack! UseAsyncRendering() can incorrectly return false
         396                 :   // when we don't have an object frame (possible as of bug 90268).
         397                 :   // We hack around this by always returning true if we've ever
         398                 :   // returned true.
         399                 :   bool mUseAsyncRendering;
         400                 : #endif
         401                 :
         402                 :   // pointer to wrapper for nsIDOMContextMenuListener
         403                 :   nsRefPtr<nsPluginDOMContextMenuListener> mCXMenuListener;
         404                 :
         405                 :   nsresult DispatchKeyToPlugin(nsIDOMEvent* aKeyEvent);
         406                 :   nsresult DispatchMouseToPlugin(nsIDOMEvent* aMouseEvent);
         407                 :   nsresult DispatchFocusToPlugin(nsIDOMEvent* aFocusEvent);
         408                 :
         409                 :   nsresult EnsureCachedAttrParamArrays();
         410                 :
         411                 : #ifdef MOZ_X11
         412                 :   class Renderer
         413                 : #if defined(MOZ_WIDGET_GTK2)
         414                 :   : public gfxXlibNativeRenderer
         415                 : #elif defined(MOZ_WIDGET_QT)
         416                 :   : public gfxQtNativeRenderer
         417                 : #endif
         418                 :   {
         419                 :   public:
         420               0 :     Renderer(NPWindow* aWindow, nsPluginInstanceOwner* aInstanceOwner,
         421                 :              const nsIntSize& aPluginSize, const nsIntRect& aDirtyRect)
         422                 :     : mWindow(aWindow), mInstanceOwner(aInstanceOwner),
         423               0 :     mPluginSize(aPluginSize), mDirtyRect(aDirtyRect)
         424               0 :     {}
         425                 :     virtual nsresult DrawWithXlib(gfxXlibSurface* surface, nsIntPoint offset,
         426                 :                                   nsIntRect* clipRects, PRUint32 numClipRects);
         427                 :   private:
         428                 :     NPWindow* mWindow;
         429                 :     nsPluginInstanceOwner* mInstanceOwner;
         430                 :     const nsIntSize& mPluginSize;
         431                 :     const nsIntRect& mDirtyRect;
         432                 :   };
         433                 : #endif
         434                 :
         435                 :   bool mWaitingForPaint;
         436                 : };
         437                 :
         438                 : #endif // nsPluginInstanceOwner_h_
         439                 :

Generated by: LCOV version 1.7