layout/generic/nsObjectFrame.h

   1 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* This Source Code Form is subject to the terms of the Mozilla Public
   3  * License, v. 2.0. If a copy of the MPL was not distributed with this
   4  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   5
   6 /* rendering objects for replaced elements implemented by a plugin */
   7
   8 #ifndef nsObjectFrame_h___
   9 #define nsObjectFrame_h___
  10
  11 #include "mozilla/Attributes.h"
  12 #include "nsIObjectFrame.h"
  13 #include "nsFrame.h"
  14 #include "nsRegion.h"
  15 #include "nsDisplayList.h"
  16 #include "nsIReflowCallback.h"
  17
  18 #ifdef XP_WIN
  19 #include <windows.h> // For HWND :(
  20 // Undo the windows.h damage
  21 #undef GetMessage
  22 #undef CreateEvent
  23 #undef GetClassName
  24 #undef GetBinaryType
  25 #undef RemoveDirectory
  26 #endif
  27
  28 class nsPresContext;
  29 class nsRootPresContext;
  30 class nsDisplayPlugin;
  31 class nsIOSurface;
  32 class PluginBackgroundSink;
  33 class nsPluginInstanceOwner;
  34
  35 namespace mozilla {
  36 namespace layers {
  37 class ImageContainer;
  38 class Layer;
  39 class LayerManager;
  40 }
  41 }
  42
  43 typedef nsFrame nsObjectFrameSuper;
  44
  45 class nsObjectFrame : public nsObjectFrameSuper,
  46                       public nsIObjectFrame,
  47                       public nsIReflowCallback {
  48 public:
  49   typedef mozilla::LayerState LayerState;
  50   typedef mozilla::layers::Layer Layer;
  51   typedef mozilla::layers::LayerManager LayerManager;
  52   typedef mozilla::layers::ImageContainer ImageContainer;
  53   typedef mozilla::ContainerLayerParameters ContainerLayerParameters;
  54
  55   NS_DECL_FRAMEARENA_HELPERS
  56
  57   friend nsIFrame* NS_NewObjectFrame(nsIPresShell* aPresShell, nsStyleContext* aContext);
  58
  59   NS_DECL_QUERYFRAME
  60   NS_DECL_QUERYFRAME_TARGET(nsObjectFrame)
  61
  62   virtual void Init(nsIContent*       aContent,
  63                     nsContainerFrame* aParent,
  64                     nsIFrame*         aPrevInFlow) MOZ_OVERRIDE;
  65   virtual nscoord GetMinISize(nsRenderingContext *aRenderingContext) MOZ_OVERRIDE;
  66   virtual nscoord GetPrefISize(nsRenderingContext *aRenderingContext) MOZ_OVERRIDE;
  67   virtual void Reflow(nsPresContext* aPresContext,
  68                       nsHTMLReflowMetrics& aDesiredSize,
  69                       const nsHTMLReflowState& aReflowState,
  70                       nsReflowStatus& aStatus) MOZ_OVERRIDE;
  71   virtual void DidReflow(nsPresContext* aPresContext,
  72                          const nsHTMLReflowState* aReflowState,
  73                          nsDidReflowStatus aStatus) MOZ_OVERRIDE;
  74   virtual void BuildDisplayList(nsDisplayListBuilder*   aBuilder,
  75                                 const nsRect&           aDirtyRect,
  76                                 const nsDisplayListSet& aLists) MOZ_OVERRIDE;
  77
  78   virtual nsresult  HandleEvent(nsPresContext* aPresContext,
  79                                 mozilla::WidgetGUIEvent* aEvent,
  80                                 nsEventStatus* aEventStatus) MOZ_OVERRIDE;
  81
  82   virtual nsIAtom* GetType() const MOZ_OVERRIDE;
  83
  84   virtual bool IsFrameOfType(uint32_t aFlags) const MOZ_OVERRIDE
  85   {
  86     return nsObjectFrameSuper::IsFrameOfType(aFlags & ~(nsIFrame::eReplaced));
  87   }
  88
  89   virtual bool NeedsView() MOZ_OVERRIDE { return true; }
  90
  91 #ifdef DEBUG_FRAME_DUMP
  92   virtual nsresult GetFrameName(nsAString& aResult) const MOZ_OVERRIDE;
  93 #endif
  94
  95   virtual void DestroyFrom(nsIFrame* aDestructRoot) MOZ_OVERRIDE;
  96
  97   virtual void DidSetStyleContext(nsStyleContext* aOldStyleContext) MOZ_OVERRIDE;
  98
  99   NS_METHOD GetPluginInstance(nsNPAPIPluginInstance** aPluginInstance) MOZ_OVERRIDE;
 100
 101   virtual void SetIsDocumentActive(bool aIsActive) MOZ_OVERRIDE;
 102
 103   virtual nsresult GetCursor(const nsPoint& aPoint,
 104                              nsIFrame::Cursor& aCursor) MOZ_OVERRIDE;
 105
 106   // APIs used by nsRootPresContext to set up the widget position/size/clip
 107   // region.
 108   /**
 109    * Set the next widget configuration for the plugin to the desired
 110    * position of the plugin's widget, on the assumption that it is not visible
 111    * (clipped out or covered by opaque content).
 112    * This will only be called for plugins which have been registered
 113    * with the root pres context for geometry updates.
 114    * If there is no widget associated with the plugin, this will have no effect.
 115    */
 116   void SetEmptyWidgetConfiguration()
 117   {
 118     mNextConfigurationBounds = nsIntRect(0,0,0,0);
 119     mNextConfigurationClipRegion.Clear();
 120   }
 121   /**
 122    * Append the desired widget configuration to aConfigurations.
 123    */
 124   void GetWidgetConfiguration(nsTArray<nsIWidget::Configuration>* aConfigurations)
 125   {
 126     if (mWidget) {
 127       if (!mWidget->GetParent()) {
 128         // Plugin widgets should not be toplevel except when they're out of the
 129         // document, in which case the plugin should not be registered for
 130         // geometry updates and this should not be called. But apparently we
 131         // have bugs where mWidget sometimes is toplevel here. Bail out.
 132         NS_ERROR("Plugin widgets registered for geometry updates should not be toplevel");
 133         return;
 134       }
 135       nsIWidget::Configuration* configuration = aConfigurations->AppendElement();
 136       configuration->mChild = mWidget;
 137       configuration->mBounds = mNextConfigurationBounds;
 138       configuration->mClipRegion = mNextConfigurationClipRegion;
 139     }
 140   }
 141   /**
 142    * Called after all widget position/size/clip regions have been changed
 143    * (even if there isn't a widget for this plugin).
 144    */
 145   void DidSetWidgetGeometry();
 146
 147   // accessibility support
 148 #ifdef ACCESSIBILITY
 149   virtual mozilla::a11y::AccType AccessibleType() MOZ_OVERRIDE;
 150 #ifdef XP_WIN
 151   NS_IMETHOD GetPluginPort(HWND *aPort);
 152 #endif
 153 #endif
 154
 155   //local methods
 156   nsresult PrepForDrawing(nsIWidget *aWidget);
 157
 158   // for a given aRoot, this walks the frame tree looking for the next outFrame
 159   static nsIObjectFrame* GetNextObjectFrame(nsPresContext* aPresContext,
 160                                             nsIFrame* aRoot);
 161
 162   // nsIReflowCallback
 163   virtual bool ReflowFinished() MOZ_OVERRIDE;
 164   virtual void ReflowCallbackCanceled() MOZ_OVERRIDE;
 165
 166   /**
 167    * Builds either an ImageLayer or a ReadbackLayer, depending on the type
 168    * of aItem (TYPE_PLUGIN or TYPE_PLUGIN_READBACK respectively).
 169    */
 170   already_AddRefed<Layer> BuildLayer(nsDisplayListBuilder* aBuilder,
 171                                      LayerManager* aManager,
 172                                      nsDisplayItem* aItem,
 173                                      const ContainerLayerParameters& aContainerParameters);
 174
 175   LayerState GetLayerState(nsDisplayListBuilder* aBuilder,
 176                            LayerManager* aManager);
 177
 178   /**
 179    * Get the rectangle (relative to this frame) which it will paint. Normally
 180    * the frame's content-box but may be smaller if the plugin is rendering
 181    * asynchronously and has a different-sized image temporarily.
 182    */
 183   nsRect GetPaintedRect(nsDisplayPlugin* aItem);
 184
 185   /**
 186    * If aSupports has a nsObjectFrame, then prepare it for a DocShell swap.
 187    * @see nsSubDocumentFrame::BeginSwapDocShells.
 188    * There will be a call to EndSwapDocShells after we were moved to the
 189    * new view tree.
 190    */
 191   static void BeginSwapDocShells(nsISupports* aSupports, void*);
 192   /**
 193    * If aSupports has a nsObjectFrame, then set it up after a DocShell swap.
 194    * @see nsSubDocumentFrame::EndSwapDocShells.
 195    */
 196   static void EndSwapDocShells(nsISupports* aSupports, void*);
 197
 198   nsIWidget* GetWidget() MOZ_OVERRIDE { return mInnerView ? mWidget : nullptr; }
 199
 200   /**
 201    * Adjust the plugin's idea of its size, using aSize as its new size.
 202    * (aSize must be in twips)
 203    */
 204   void FixupWindow(const nsSize& aSize);
 205
 206   /*
 207    * Sets up the plugin window and calls SetWindow on the plugin.
 208    */
 209   nsresult CallSetWindow(bool aCheckIsHidden = true);
 210
 211   void SetInstanceOwner(nsPluginInstanceOwner* aOwner);
 212
 213 protected:
 214   explicit nsObjectFrame(nsStyleContext* aContext);
 215   virtual ~nsObjectFrame();
 216
 217   // NOTE:  This frame class does not inherit from |nsLeafFrame|, so
 218   // this is not a virtual method implementation.
 219   void GetDesiredSize(nsPresContext* aPresContext,
 220                       const nsHTMLReflowState& aReflowState,
 221                       nsHTMLReflowMetrics& aDesiredSize);
 222
 223   bool IsFocusable(int32_t *aTabIndex = nullptr,
 224                    bool aWithMouse = false) MOZ_OVERRIDE;
 225
 226   // check attributes and optionally CSS to see if we should display anything
 227   bool IsHidden(bool aCheckVisibilityStyle = true) const;
 228
 229   bool IsOpaque() const;
 230   bool IsTransparentMode() const;
 231   bool IsPaintedByGecko() const;
 232
 233   nsIntPoint GetWindowOriginInPixels(bool aWindowless);
 234
 235   static void PaintPrintPlugin(nsIFrame* aFrame,
 236                                nsRenderingContext* aRenderingContext,
 237                                const nsRect& aDirtyRect, nsPoint aPt);
 238   void PrintPlugin(nsRenderingContext& aRenderingContext,
 239                    const nsRect& aDirtyRect);
 240   void PaintPlugin(nsDisplayListBuilder* aBuilder,
 241                    nsRenderingContext& aRenderingContext,
 242                    const nsRect& aDirtyRect, const nsRect& aPluginRect);
 243
 244   void NotifyPluginReflowObservers();
 245
 246   friend class nsPluginInstanceOwner;
 247   friend class nsDisplayPlugin;
 248   friend class PluginBackgroundSink;
 249
 250 private:
 251   // Registers the plugin for a geometry update, and requests a geometry
 252   // update. This caches the root pres context in
 253   // mRootPresContextRegisteredWith, so that we can be sure we unregister
 254   // from the right root prest context in UnregisterPluginForGeometryUpdates.
 255   void RegisterPluginForGeometryUpdates();
 256
 257   // Unregisters the plugin for geometry updated with the root pres context
 258   // stored in mRootPresContextRegisteredWith.
 259   void UnregisterPluginForGeometryUpdates();
 260
 261   class PluginEventNotifier : public nsRunnable {
 262   public:
 263     explicit PluginEventNotifier(const nsString &aEventType) :
 264       mEventType(aEventType) {}
 265
 266     NS_IMETHOD Run() MOZ_OVERRIDE;
 267   private:
 268     nsString mEventType;
 269   };
 270
 271   nsPluginInstanceOwner*          mInstanceOwner; // WEAK
 272   nsView*                        mInnerView;
 273   nsCOMPtr<nsIWidget>             mWidget;
 274   nsIntRect                       mWindowlessRect;
 275   /**
 276    * This is owned by the ReadbackLayer for this nsObjectFrame. It is
 277    * automatically cleared if the PluginBackgroundSink is destroyed.
 278    */
 279   PluginBackgroundSink*           mBackgroundSink;
 280
 281   /**
 282    * Bounds that we should set the plugin's widget to in the next composite,
 283    * for plugins with widgets. For plugins without widgets, bounds in device
 284    * pixels relative to the nearest frame that's a display list reference frame.
 285    */
 286   nsIntRect                       mNextConfigurationBounds;
 287   /**
 288    * Clip region that we should set the plugin's widget to
 289    * in the next composite. Only meaningful for plugins with widgets.
 290    */
 291   nsTArray<nsIntRect>             mNextConfigurationClipRegion;
 292
 293   bool mReflowCallbackPosted;
 294
 295   // We keep this reference to ensure we can always unregister the
 296   // plugins we register on the root PresContext.
 297   // This is only non-null while we have a plugin registered for geometry
 298   // updates.
 299   nsRefPtr<nsRootPresContext> mRootPresContextRegisteredWith;
 300 };
 301
 302 class nsDisplayPlugin : public nsDisplayItem {
 303 public:
 304   nsDisplayPlugin(nsDisplayListBuilder* aBuilder, nsIFrame* aFrame)
 305     : nsDisplayItem(aBuilder, aFrame)
 306   {
 307     MOZ_COUNT_CTOR(nsDisplayPlugin);
 308     aBuilder->SetContainsPluginItem();
 309   }
 310 #ifdef NS_BUILD_REFCNT_LOGGING
 311   virtual ~nsDisplayPlugin() {
 312     MOZ_COUNT_DTOR(nsDisplayPlugin);
 313   }
 314 #endif
 315
 316   virtual nsRect GetBounds(nsDisplayListBuilder* aBuilder, bool* aSnap) MOZ_OVERRIDE;
 317   virtual nsRegion GetOpaqueRegion(nsDisplayListBuilder* aBuilder,
 318                                    bool* aSnap) MOZ_OVERRIDE;
 319   virtual void Paint(nsDisplayListBuilder* aBuilder,
 320                      nsRenderingContext* aCtx) MOZ_OVERRIDE;
 321   virtual bool ComputeVisibility(nsDisplayListBuilder* aBuilder,
 322                                  nsRegion* aVisibleRegion) MOZ_OVERRIDE;
 323
 324   NS_DISPLAY_DECL_NAME("Plugin", TYPE_PLUGIN)
 325
 326   virtual already_AddRefed<Layer> BuildLayer(nsDisplayListBuilder* aBuilder,
 327                                              LayerManager* aManager,
 328                                              const ContainerLayerParameters& aContainerParameters) MOZ_OVERRIDE
 329   {
 330     return static_cast<nsObjectFrame*>(mFrame)->BuildLayer(aBuilder,
 331                                                            aManager,
 332                                                            this,
 333                                                            aContainerParameters);
 334   }
 335
 336   virtual LayerState GetLayerState(nsDisplayListBuilder* aBuilder,
 337                                    LayerManager* aManager,
 338                                    const ContainerLayerParameters& aParameters) MOZ_OVERRIDE
 339   {
 340     return static_cast<nsObjectFrame*>(mFrame)->GetLayerState(aBuilder,
 341                                                               aManager);
 342   }
 343 };
 344
 345 #endif /* nsObjectFrame_h___ */