author Boris Zbarsky <>
Sat, 11 May 2019 08:28:29 +0000
changeset 532359 6103006e3172f0ef258a30256b8cc7a6553e7f14
parent 531887 69a48ceb1ecb6c0857a5a258d653be3b0a7b93b6
permissions -rw-r--r--
Bug 1550937. Stop using [array] in nsIEventListenerService. r=smaug Differential Revision:

/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at */

/* rendering objects for replaced elements implemented by a plugin */

#ifndef nsPluginFrame_h___
#define nsPluginFrame_h___

#include "mozilla/Attributes.h"
#include "mozilla/EventForwards.h"
#include "mozilla/UniquePtr.h"
#include "nsIObjectFrame.h"
#include "nsFrame.h"
#include "nsRegion.h"
#include "nsDisplayList.h"
#include "nsIReflowCallback.h"
#include "Units.h"
#include "mozilla/layers/StackingContextHelper.h"
#include "mozilla/webrender/WebRenderAPI.h"

#ifdef XP_WIN
#  include <windows.h>  // For HWND :(
// Undo the windows.h damage
#  undef GetMessage
#  undef CreateEvent
#  undef GetClassName
#  undef GetBinaryType
#  undef RemoveDirectory
#  undef LoadIcon
#  undef LoadImage
#  undef GetObject

class nsPresContext;
class nsRootPresContext;
class nsDisplayPlugin;
class PluginBackgroundSink;
class nsPluginInstanceOwner;

namespace mozilla {
class PresShell;
namespace layers {
class ImageContainer;
class Layer;
class LayerManager;
}  // namespace layers
}  // namespace mozilla

class PluginFrameDidCompositeObserver;

class nsPluginFrame final : public nsFrame,
                            public nsIObjectFrame,
                            public nsIReflowCallback {
  typedef mozilla::LayerState LayerState;
  typedef mozilla::LayoutDeviceIntPoint LayoutDeviceIntPoint;
  typedef mozilla::LayoutDeviceIntRect LayoutDeviceIntRect;
  typedef mozilla::LayoutDeviceIntRegion LayoutDeviceIntRegion;
  typedef mozilla::layers::Layer Layer;
  typedef mozilla::layers::LayerManager LayerManager;
  typedef mozilla::layers::ImageContainer ImageContainer;
  typedef mozilla::layers::StackingContextHelper StackingContextHelper;
  typedef mozilla::layers::RenderRootStateManager RenderRootStateManager;
  typedef mozilla::layers::WebRenderParentCommand WebRenderParentCommand;
  typedef mozilla::ContainerLayerParameters ContainerLayerParameters;


  friend nsIFrame* NS_NewObjectFrame(mozilla::PresShell* aPresShell,
                                     ComputedStyle* aStyle);

  virtual void Init(nsIContent* aContent, nsContainerFrame* aParent,
                    nsIFrame* aPrevInFlow) override;
  virtual nscoord GetMinISize(gfxContext* aRenderingContext) override;
  virtual nscoord GetPrefISize(gfxContext* aRenderingContext) override;
  virtual void Reflow(nsPresContext* aPresContext, ReflowOutput& aDesiredSize,
                      const ReflowInput& aReflowInput,
                      nsReflowStatus& aStatus) override;
  virtual void DidReflow(nsPresContext* aPresContext,
                         const ReflowInput* aReflowInput) override;
  virtual void BuildDisplayList(nsDisplayListBuilder* aBuilder,
                                const nsDisplayListSet& aLists) override;

  virtual nsresult HandleEvent(nsPresContext* aPresContext,
                               mozilla::WidgetGUIEvent* aEvent,
                               nsEventStatus* aEventStatus) override;

  virtual bool IsFrameOfType(uint32_t aFlags) const override {
    return nsFrame::IsFrameOfType(
        aFlags & ~(nsIFrame::eReplaced | nsIFrame::eReplacedSizing));

  virtual nsresult GetFrameName(nsAString& aResult) const override;

  virtual void DestroyFrom(nsIFrame* aDestructRoot,
                           PostDestroyData& aPostDestroyData) override;

  virtual void DidSetComputedStyle(ComputedStyle* aOldComputedStyle) override;

  nsNPAPIPluginInstance* GetPluginInstance() override;

  virtual void SetIsDocumentActive(bool aIsActive) override;

  mozilla::Maybe<Cursor> GetCursor(const nsPoint&) override;

  // APIs used by nsRootPresContext to set up the widget position/size/clip
  // region.
   * Set the next widget configuration for the plugin to the desired
   * position of the plugin's widget, on the assumption that it is not visible
   * (clipped out or covered by opaque content).
   * This will only be called for plugins which have been registered
   * with the root pres context for geometry updates.
   * If there is no widget associated with the plugin, this will have no effect.
  void SetEmptyWidgetConfiguration() {
    mNextConfigurationBounds = LayoutDeviceIntRect(0, 0, 0, 0);
   * Append the desired widget configuration to aConfigurations.
  void GetWidgetConfiguration(
      nsTArray<nsIWidget::Configuration>* aConfigurations);

  LayoutDeviceIntRect GetWidgetlessClipRect() {
    return RegionFromArray(mNextConfigurationClipRegion).GetBounds();

   * Called after all widget position/size/clip regions have been changed
   * (even if there isn't a widget for this plugin).
  void DidSetWidgetGeometry();

  // accessibility support
  virtual mozilla::a11y::AccType AccessibleType() override;
#  ifdef XP_WIN
  NS_IMETHOD GetPluginPort(HWND* aPort);
#  endif

  // local methods
  nsresult PrepForDrawing(nsIWidget* aWidget);

  // for a given aRoot, this walks the frame tree looking for the next outFrame
  static nsIObjectFrame* GetNextObjectFrame(nsPresContext* aPresContext,
                                            nsIFrame* aRoot);

  // nsIReflowCallback
  virtual bool ReflowFinished() override;
  virtual void ReflowCallbackCanceled() override;

   * Builds either an ImageLayer or a ReadbackLayer, depending on the type
   * of aItem (TYPE_PLUGIN or TYPE_PLUGIN_READBACK respectively).
  already_AddRefed<Layer> BuildLayer(
      nsDisplayListBuilder* aBuilder, LayerManager* aManager,
      nsDisplayItem* aItem,
      const ContainerLayerParameters& aContainerParameters);

  LayerState GetLayerState(nsDisplayListBuilder* aBuilder,
                           LayerManager* aManager);

   * Get the rectangle (relative to this frame) which it will paint. Normally
   * the frame's content-box but may be smaller if the plugin is rendering
   * asynchronously and has a different-sized image temporarily.
  nsRect GetPaintedRect(const nsDisplayPlugin* aItem) const;

   * If aSupports has a nsPluginFrame, then prepare it for a DocShell swap.
   * @see nsSubDocumentFrame::BeginSwapDocShells.
   * There will be a call to EndSwapDocShells after we were moved to the
   * new view tree.
  static void BeginSwapDocShells(nsISupports* aSupports, void*);
   * If aSupports has a nsPluginFrame, then set it up after a DocShell swap.
   * @see nsSubDocumentFrame::EndSwapDocShells.
  static void EndSwapDocShells(nsISupports* aSupports, void*);

  nsIWidget* GetWidget() override {
    if (!mInnerView) {
      return nullptr;
    return mWidget;

   * Adjust the plugin's idea of its size, using aSize as its new size.
   * (aSize must be in twips)
  void FixupWindow(const nsSize& aSize);

   * Sets up the plugin window and calls SetWindow on the plugin.
  nsresult CallSetWindow(bool aCheckIsHidden = true);

  void SetInstanceOwner(nsPluginInstanceOwner* aOwner);

   * HandleWheelEventAsDefaultAction() handles eWheel event as default action.
   * This should be called only when WantsToHandleWheelEventAsDefaultAction()
   * returns true.
  void HandleWheelEventAsDefaultAction(mozilla::WidgetWheelEvent* aEvent);

   * WantsToHandleWheelEventAsDefaultAction() returns true if the plugin
   * may want to handle wheel events as default action.
  bool WantsToHandleWheelEventAsDefaultAction() const;

  bool CreateWebRenderCommands(
      nsDisplayItem* aItem, mozilla::wr::DisplayListBuilder& aBuilder,
      mozilla::wr::IpcResourceUpdateQueue& aResources,
      const StackingContextHelper& aSc,
      mozilla::layers::RenderRootStateManager* aManager,
      nsDisplayListBuilder* aDisplayListBuilder);

  explicit nsPluginFrame(ComputedStyle* aStyle, nsPresContext* aPresContext);
  virtual ~nsPluginFrame();

  // NOTE:  This frame class does not inherit from |nsLeafFrame|, so
  // this is not a virtual method implementation.
  void GetDesiredSize(nsPresContext* aPresContext,
                      const ReflowInput& aReflowInput,
                      ReflowOutput& aDesiredSize);

  bool IsFocusable(int32_t* aTabIndex = nullptr,
                   bool aWithMouse = false) override;

  // check attributes and optionally CSS to see if we should display anything
  bool IsHidden(bool aCheckVisibilityStyle = true) const;

  bool IsOpaque() const;
  bool IsTransparentMode() const;
  bool IsPaintedByGecko() const;

  nsIntPoint GetWindowOriginInPixels(bool aWindowless);

   * If this frame is in a remote tab, return the tab offset to
   * the origin of the chrome window. In non-e10s, this return 0,0.
   * This api sends a sync ipc request so be careful about use.
  LayoutDeviceIntPoint GetRemoteTabChromeOffset();

  static void PaintPrintPlugin(nsIFrame* aFrame, gfxContext* aRenderingContext,
                               const nsRect& aDirtyRect, nsPoint aPt);
  void PrintPlugin(gfxContext& aRenderingContext, const nsRect& aDirtyRect);
  void PaintPlugin(nsDisplayListBuilder* aBuilder,
                   gfxContext& aRenderingContext, const nsRect& aDirtyRect,
                   const nsRect& aPluginRect);

  void NotifyPluginReflowObservers();

  friend class nsPluginInstanceOwner;
  friend class nsDisplayPlugin;
  friend class PluginBackgroundSink;

  nsView* GetViewInternal() const override { return mOuterView; }
  void SetViewInternal(nsView* aView) override { mOuterView = aView; }
  bool GetBounds(nsDisplayItem* aItem, mozilla::gfx::IntSize& aSize,
                 gfxRect& aRect);

  // Registers the plugin for a geometry update, and requests a geometry
  // update. This caches the root pres context in
  // mRootPresContextRegisteredWith, so that we can be sure we unregister
  // from the right root prest context in UnregisterPluginForGeometryUpdates.
  void RegisterPluginForGeometryUpdates();

  // Unregisters the plugin for geometry updated with the root pres context
  // stored in mRootPresContextRegisteredWith.
  void UnregisterPluginForGeometryUpdates();

  static const LayoutDeviceIntRegion RegionFromArray(
      const nsTArray<LayoutDeviceIntRect>& aRects) {
    LayoutDeviceIntRegion region;
    for (uint32_t i = 0; i < aRects.Length(); ++i) {
      region.Or(region, aRects[i]);
    return region;

  class PluginEventNotifier : public mozilla::Runnable {
    explicit PluginEventNotifier(const nsString& aEventType)
        : mozilla::Runnable("nsPluginFrame::PluginEventNotifier"),
          mEventType(aEventType) {}

    NS_IMETHOD Run() override;

    nsString mEventType;

  nsPluginInstanceOwner* mInstanceOwner;  // WEAK
  nsView* mOuterView;
  nsView* mInnerView;
  nsCOMPtr<nsIWidget> mWidget;
  nsIntRect mWindowlessRect;
   * This is owned by the ReadbackLayer for this nsPluginFrame. It is
   * automatically cleared if the PluginBackgroundSink is destroyed.
  PluginBackgroundSink* mBackgroundSink;

   * Bounds that we should set the plugin's widget to in the next composite,
   * for plugins with widgets. For plugins without widgets, bounds in device
   * pixels relative to the nearest frame that's a display list reference frame.
  LayoutDeviceIntRect mNextConfigurationBounds;
   * Clip region that we should set the plugin's widget to
   * in the next composite. Only meaningful for plugins with widgets.
  nsTArray<LayoutDeviceIntRect> mNextConfigurationClipRegion;

  bool mReflowCallbackPosted;

  // We keep this reference to ensure we can always unregister the
  // plugins we register on the root PresContext.
  // This is only non-null while we have a plugin registered for geometry
  // updates.
  RefPtr<nsRootPresContext> mRootPresContextRegisteredWith;

  mozilla::UniquePtr<PluginFrameDidCompositeObserver> mDidCompositeObserver;

class nsDisplayPluginGeometry : public nsDisplayItemGenericGeometry {
  nsDisplayPluginGeometry(nsDisplayItem* aItem, nsDisplayListBuilder* aBuilder)
      : nsDisplayItemGenericGeometry(aItem, aBuilder) {}

  // Plugins MozPaintWait event depends on sync decode, so we always want
  // to rebuild the display list when sync decoding.
  virtual bool InvalidateForSyncDecodeImages() const override { return true; }

class nsDisplayPlugin final : public nsPaintedDisplayItem {
  nsDisplayPlugin(nsDisplayListBuilder* aBuilder, nsIFrame* aFrame)
      : nsPaintedDisplayItem(aBuilder, aFrame) {
  virtual ~nsDisplayPlugin() { MOZ_COUNT_DTOR(nsDisplayPlugin); }

  virtual nsRect GetBounds(nsDisplayListBuilder* aBuilder,
                           bool* aSnap) const override;
  virtual nsRegion GetOpaqueRegion(nsDisplayListBuilder* aBuilder,
                                   bool* aSnap) const override;
  virtual void Paint(nsDisplayListBuilder* aBuilder, gfxContext* aCtx) override;
  virtual bool ComputeVisibility(nsDisplayListBuilder* aBuilder,
                                 nsRegion* aVisibleRegion) override;


  virtual already_AddRefed<Layer> BuildLayer(
      nsDisplayListBuilder* aBuilder, LayerManager* aManager,
      const ContainerLayerParameters& aContainerParameters) override {
    return static_cast<nsPluginFrame*>(mFrame)->BuildLayer(
        aBuilder, aManager, this, aContainerParameters);

  virtual LayerState GetLayerState(
      nsDisplayListBuilder* aBuilder, LayerManager* aManager,
      const ContainerLayerParameters& aParameters) override {
    return static_cast<nsPluginFrame*>(mFrame)->GetLayerState(aBuilder,

  virtual nsDisplayItemGeometry* AllocateGeometry(
      nsDisplayListBuilder* aBuilder) override {
    return new nsDisplayPluginGeometry(this, aBuilder);

  virtual bool CreateWebRenderCommands(
      mozilla::wr::DisplayListBuilder& aBuilder,
      mozilla::wr::IpcResourceUpdateQueue& aResources,
      const StackingContextHelper& aSc,
      mozilla::layers::RenderRootStateManager* aManager,
      nsDisplayListBuilder* aDisplayListBuilder) override;

#endif /* nsPluginFrame_h___ */