/* -*- 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 http://mozilla.org/MPL/2.0/. */

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

#include "nsPluginFrame.h"

#include "gfx2DGlue.h"
#include "gfxContext.h"
#include "gfxMatrix.h"
#include "mozilla/gfx/2D.h"
#include "mozilla/BasicEvents.h"
#include "mozilla/MouseEvents.h"
#include "mozilla/PresShell.h"
#ifdef XP_WIN
// This is needed for DoublePassRenderingEvent.
#  include "mozilla/plugins/PluginMessageUtils.h"
#endif

#include "nscore.h"
#include "nsCOMPtr.h"
#include "nsPresContext.h"
#include "nsWidgetsCID.h"
#include "nsView.h"
#include "nsViewManager.h"
#include "nsString.h"
#include "nsGkAtoms.h"
#include "nsNPAPIPluginInstance.h"
#include "npapi.h"
#include "nsIObjectLoadingContent.h"
#include "nsContentUtils.h"
#include "nsDisplayList.h"
#include "nsFocusManager.h"
#include "nsLayoutUtils.h"
#include "nsFrameManager.h"
#include "nsIObserverService.h"
#include "GeckoProfiler.h"
#include <algorithm>

#include "nsIObjectFrame.h"
#include "nsPluginNativeWindow.h"
#include "FrameLayerBuilder.h"

#include "ImageLayers.h"
#include "nsPluginInstanceOwner.h"

#ifdef XP_WIN
#  include "gfxWindowsNativeDrawing.h"
#  include "gfxWindowsSurface.h"
#endif

#include "Layers.h"
#include "ReadbackLayer.h"
#include "ImageContainer.h"
#include "mozilla/layers/RenderRootStateManager.h"

// accessibility support
#ifdef ACCESSIBILITY
#  include "nsAccessibilityService.h"
#endif

#include "mozilla/Logging.h"

#ifdef XP_MACOSX
#  include "gfxQuartzNativeDrawing.h"
#  include "mozilla/gfx/QuartzSupport.h"
#endif

#ifdef MOZ_X11
#  include "mozilla/X11Util.h"
#endif

#ifdef XP_WIN
#  include <wtypes.h>
#  include <winuser.h>
#endif

#include "mozilla/dom/BrowserChild.h"

#ifdef CreateEvent  // Thank you MS.
#  undef CreateEvent
#endif

static mozilla::LazyLogModule sPluginFrameLog("nsPluginFrame");

using namespace mozilla;
using namespace mozilla::gfx;
using namespace mozilla::layers;

class PluginBackgroundSink : public ReadbackSink {
 public:
  PluginBackgroundSink(nsPluginFrame* aFrame, uint64_t aStartSequenceNumber)
      : mLastSequenceNumber(aStartSequenceNumber), mFrame(aFrame) {}
  ~PluginBackgroundSink() override {
    if (mFrame) {
      mFrame->mBackgroundSink = nullptr;
    }
  }

  void SetUnknown(uint64_t aSequenceNumber) override {
    if (!AcceptUpdate(aSequenceNumber)) return;
    mFrame->mInstanceOwner->SetBackgroundUnknown();
  }

  already_AddRefed<DrawTarget> BeginUpdate(const nsIntRect& aRect,
                                           uint64_t aSequenceNumber) override {
    if (!AcceptUpdate(aSequenceNumber)) return nullptr;
    return mFrame->mInstanceOwner->BeginUpdateBackground(aRect);
  }

  void EndUpdate(const nsIntRect& aRect) override {
    return mFrame->mInstanceOwner->EndUpdateBackground(aRect);
  }

  void Destroy() { mFrame = nullptr; }

 protected:
  bool AcceptUpdate(uint64_t aSequenceNumber) {
    if (aSequenceNumber > mLastSequenceNumber && mFrame &&
        mFrame->mInstanceOwner) {
      mLastSequenceNumber = aSequenceNumber;
      return true;
    }
    return false;
  }

  uint64_t mLastSequenceNumber;
  nsPluginFrame* mFrame;
};

nsPluginFrame::nsPluginFrame(ComputedStyle* aStyle, nsPresContext* aPresContext)
    : nsIFrame(aStyle, aPresContext, kClassID),
      mInstanceOwner(nullptr),
      mOuterView(nullptr),
      mInnerView(nullptr),
      mBackgroundSink(nullptr),
      mReflowCallbackPosted(false) {
  MOZ_LOG(sPluginFrameLog, LogLevel::Debug,
          ("Created new nsPluginFrame %p\n", this));
}

nsPluginFrame::~nsPluginFrame() {
  MOZ_LOG(sPluginFrameLog, LogLevel::Debug,
          ("nsPluginFrame %p deleted\n", this));
}

NS_QUERYFRAME_HEAD(nsPluginFrame)
  NS_QUERYFRAME_ENTRY(nsPluginFrame)
  NS_QUERYFRAME_ENTRY(nsIObjectFrame)
NS_QUERYFRAME_TAIL_INHERITING(nsIFrame)

#ifdef ACCESSIBILITY
a11y::AccType nsPluginFrame::AccessibleType() { return a11y::ePluginType; }

#  ifdef XP_WIN
NS_IMETHODIMP nsPluginFrame::GetPluginPort(HWND* aPort) {
  *aPort = (HWND)mInstanceOwner->GetPluginPort();
  return NS_OK;
}
#  endif
#endif

void nsPluginFrame::Init(nsIContent* aContent, nsContainerFrame* aParent,
                         nsIFrame* aPrevInFlow) {
  MOZ_LOG(sPluginFrameLog, LogLevel::Debug,
          ("Initializing nsPluginFrame %p for content %p\n", this, aContent));

  nsIFrame::Init(aContent, aParent, aPrevInFlow);
  CreateView();
}

void nsPluginFrame::DestroyFrom(nsIFrame* aDestructRoot,
                                PostDestroyData& aPostDestroyData) {
  if (mReflowCallbackPosted) {
    PresShell()->CancelReflowCallback(this);
  }

  // Ensure our DidComposite observer is gone.
  mDidCompositeObserver = nullptr;

  // Tell content owner of the instance to disconnect its frame.
  nsCOMPtr<nsIObjectLoadingContent> objContent(do_QueryInterface(mContent));
  NS_ASSERTION(objContent, "Why not an object loading content?");

  // The content might not have a reference to the instance owner any longer in
  // the case of re-entry during instantiation or teardown, so make sure we're
  // dissociated.
  if (mInstanceOwner) {
    mInstanceOwner->SetFrame(nullptr);
  }
  objContent->HasNewFrame(nullptr);

  if (mBackgroundSink) {
    mBackgroundSink->Destroy();
  }

  nsIFrame::DestroyFrom(aDestructRoot, aPostDestroyData);
}

/* virtual */
void nsPluginFrame::DidSetComputedStyle(ComputedStyle* aOldComputedStyle) {
  if (HasView()) {
    nsView* view = GetView();
    nsViewManager* vm = view->GetViewManager();
    if (vm) {
      nsViewVisibility visibility =
          IsHidden() ? nsViewVisibility_kHide : nsViewVisibility_kShow;
      vm->SetViewVisibility(view, visibility);
    }
  }

  nsIFrame::DidSetComputedStyle(aOldComputedStyle);
}

#ifdef DEBUG_FRAME_DUMP
nsresult nsPluginFrame::GetFrameName(nsAString& aResult) const {
  return MakeFrameName(u"PluginFrame"_ns, aResult);
}
#endif

nsresult nsPluginFrame::PrepForDrawing(nsIWidget* aWidget) {
  mWidget = aWidget;

  nsView* view = GetView();
  NS_ASSERTION(view, "Object frames must have views");
  if (!view) {
    return NS_ERROR_FAILURE;
  }

  nsViewManager* viewMan = view->GetViewManager();
  // mark the view as hidden since we don't know the (x,y) until Paint
  // XXX is the above comment correct?
  viewMan->SetViewVisibility(view, nsViewVisibility_kHide);

  // this is ugly. it was ripped off from didreflow(). MMP
  // Position and size view relative to its parent, not relative to our
  // parent frame (our parent frame may not have a view).

  nsView* parentWithView;
  nsPoint origin;
  nsRect r(0, 0, mRect.width, mRect.height);

  GetOffsetFromView(origin, &parentWithView);
  viewMan->ResizeView(view, r);
  viewMan->MoveViewTo(view, origin.x, origin.y);

  nsPresContext* presContext = PresContext();
  nsRootPresContext* rpc = presContext->GetRootPresContext();
  if (!rpc) {
    return NS_ERROR_FAILURE;
  }

  if (mWidget) {
    // Disallow windowed plugins in popups
    nsIFrame* rootFrame = rpc->PresShell()->GetRootFrame();
    nsIWidget* parentWidget = rootFrame->GetNearestWidget();
    if (!parentWidget ||
        nsLayoutUtils::GetDisplayRootFrame(this) != rootFrame) {
      return NS_ERROR_FAILURE;
    }

    // We can already have mInnerView if our instance owner went away and then
    // came back. So clear the old one before creating a new one.
    if (mInnerView) {
      if (mInnerView->GetWidget()) {
        // The widget listener should have already been cleared by
        // SetInstanceOwner (with a null instance owner).
        MOZ_RELEASE_ASSERT(mInnerView->GetWidget()->GetWidgetListener() ==
                           nullptr);
      }
      mInnerView->Destroy();
      mInnerView = nullptr;
    }
    mInnerView = viewMan->CreateView(GetContentRectRelativeToSelf(), view);
    if (!mInnerView) {
      NS_ERROR("Could not create inner view");
      return NS_ERROR_OUT_OF_MEMORY;
    }
    viewMan->InsertChild(view, mInnerView, nullptr, true);

    mWidget->SetParent(parentWidget);
    mWidget->Enable(true);
    mWidget->Show(true);

    // Set the plugin window to have an empty clip region until we know
    // what our true position, size and clip region are. These
    // will be reset when nsRootPresContext computes our true
    // geometry. The plugin window does need to have a good size here, so
    // set the size explicitly to a reasonable guess.
    AutoTArray<nsIWidget::Configuration, 1> configurations;
    nsIWidget::Configuration* configuration = configurations.AppendElement();
    nscoord appUnitsPerDevPixel = presContext->AppUnitsPerDevPixel();
    configuration->mChild = mWidget;
    configuration->mBounds.width =
        NSAppUnitsToIntPixels(mRect.width, appUnitsPerDevPixel);
    configuration->mBounds.height =
        NSAppUnitsToIntPixels(mRect.height, appUnitsPerDevPixel);
    parentWidget->ConfigureChildren(configurations);

    mInnerView->AttachWidgetEventHandler(mWidget);

#ifdef XP_MACOSX
    // On Mac, we need to invalidate ourselves since even windowed
    // plugins are painted through Thebes and we need to ensure
    // the PaintedLayer containing the plugin is updated.
    if (parentWidget == GetNearestWidget()) {
      InvalidateFrame();
    }
#endif

    RegisterPluginForGeometryUpdates();

    // Here we set the background color for this widget because some plugins
    // will use the child window background color when painting. If it's not
    // set, it may default to gray Sometimes, a frame doesn't have a background
    // color or is transparent. In this case, walk up the frame tree until we do
    // find a frame with a background color
    for (nsIFrame* frame = this; frame; frame = frame->GetParent()) {
      nscolor bgcolor =
          frame->GetVisitedDependentColor(&nsStyleBackground::mBackgroundColor);
      if (NS_GET_A(bgcolor) > 0) {  // make sure we got an actual color
        mWidget->SetBackgroundColor(bgcolor);
        break;
      }
    }
  } else {
    // Changing to windowless mode changes the NPWindow geometry.
    FixupWindow(GetContentRectRelativeToSelf().Size());
    RegisterPluginForGeometryUpdates();
  }

  if (!IsHidden()) {
    viewMan->SetViewVisibility(view, nsViewVisibility_kShow);
  }

#ifdef ACCESSIBILITY
  ;
  if (nsAccessibilityService* accService =
          PresShell::GetAccessibilityService()) {
    accService->RecreateAccessible(PresShell(), mContent);
  }
#endif

  return NS_OK;
}

#define EMBED_DEF_WIDTH 240
#define EMBED_DEF_HEIGHT 200

/* virtual */
nscoord nsPluginFrame::GetMinISize(gfxContext* aRenderingContext) {
  nscoord result = 0;

  if (!IsHidden(false)) {
    if (mContent->IsHTMLElement(nsGkAtoms::embed)) {
      bool vertical = GetWritingMode().IsVertical();
      result = nsPresContext::CSSPixelsToAppUnits(vertical ? EMBED_DEF_HEIGHT
                                                           : EMBED_DEF_WIDTH);
    }
  }

  DISPLAY_MIN_INLINE_SIZE(this, result);
  return result;
}

/* virtual */
nscoord nsPluginFrame::GetPrefISize(gfxContext* aRenderingContext) {
  return nsPluginFrame::GetMinISize(aRenderingContext);
}

void nsPluginFrame::GetWidgetConfiguration(
    nsTArray<nsIWidget::Configuration>* aConfigurations) {
  if (!mWidget) {
    return;
  }

  if (!mWidget->GetParent()) {
    // Plugin widgets should not be toplevel except when they're out of the
    // document, in which case the plugin should not be registered for
    // geometry updates and this should not be called. But apparently we
    // have bugs where mWidget sometimes is toplevel here. Bail out.
    NS_ERROR(
        "Plugin widgets registered for geometry updates should not be "
        "toplevel");
    return;
  }

  nsIWidget::Configuration* configuration = aConfigurations->AppendElement();
  configuration->mChild = mWidget;
  configuration->mBounds = mNextConfigurationBounds;
  configuration->mClipRegion = mNextConfigurationClipRegion.Clone();
#if defined(XP_WIN) || defined(MOZ_WIDGET_GTK)
  if (XRE_IsContentProcess()) {
    configuration->mWindowID =
        (uintptr_t)mWidget->GetNativeData(NS_NATIVE_PLUGIN_PORT);
    configuration->mVisible = mWidget->IsVisible();
  }
#endif  // defined(XP_WIN) || defined(MOZ_WIDGET_GTK)
}

void nsPluginFrame::GetDesiredSize(nsPresContext* aPresContext,
                                   const ReflowInput& aReflowInput,
                                   ReflowOutput& aMetrics) {
  // By default, we have no area
  aMetrics.ClearSize();

  if (IsHidden(false)) {
    return;
  }

  aMetrics.Width() = aReflowInput.ComputedWidth();
  aMetrics.Height() = aReflowInput.ComputedHeight();

  // for EMBED, default to 240x200 for compatibility
  if (mContent->IsHTMLElement(nsGkAtoms::embed)) {
    if (aMetrics.Width() == NS_UNCONSTRAINEDSIZE) {
      aMetrics.Width() = clamped(
          nsPresContext::CSSPixelsToAppUnits(EMBED_DEF_WIDTH),
          aReflowInput.ComputedMinWidth(), aReflowInput.ComputedMaxWidth());
    }
    if (aMetrics.Height() == NS_UNCONSTRAINEDSIZE) {
      aMetrics.Height() = clamped(
          nsPresContext::CSSPixelsToAppUnits(EMBED_DEF_HEIGHT),
          aReflowInput.ComputedMinHeight(), aReflowInput.ComputedMaxHeight());
    }

#if defined(MOZ_WIDGET_GTK)
    // We need to make sure that the size of the object frame does not
    // exceed the maximum size of X coordinates.  See bug #225357 for
    // more information.  In theory Gtk2 can handle large coordinates,
    // but underlying plugins can't.
    aMetrics.Height() = std::min(aPresContext->DevPixelsToAppUnits(INT16_MAX),
                                 aMetrics.Height());
    aMetrics.Width() = std::min(aPresContext->DevPixelsToAppUnits(INT16_MAX),
                                aMetrics.Width());
#endif
  }

  // At this point, the width has an unconstrained value only if we have
  // nothing to go on (no width set, no information from the plugin, nothing).
  // Make up a number.
  if (aMetrics.Width() == NS_UNCONSTRAINEDSIZE) {
    aMetrics.Width() = (aReflowInput.ComputedMinWidth() != NS_UNCONSTRAINEDSIZE)
                           ? aReflowInput.ComputedMinWidth()
                           : 0;
  }

  // At this point, the height has an unconstrained value only in two cases:
  // a) We are in standards mode with percent heights and parent is auto-height
  // b) We have no height information at all.
  // In either case, we have to make up a number.
  if (aMetrics.Height() == NS_UNCONSTRAINEDSIZE) {
    aMetrics.Height() =
        (aReflowInput.ComputedMinHeight() != NS_UNCONSTRAINEDSIZE)
            ? aReflowInput.ComputedMinHeight()
            : 0;
  }

  // XXXbz don't add in the border and padding, because we screw up our
  // plugin's size and positioning if we do...  Eventually we _do_ want to
  // paint borders, though!  At that point, we will need to adjust the desired
  // size either here or in Reflow....  Further, we will need to fix Paint() to
  // call the superclass in all cases.
}

void nsPluginFrame::Reflow(nsPresContext* aPresContext, ReflowOutput& aMetrics,
                           const ReflowInput& aReflowInput,
                           nsReflowStatus& aStatus) {
  MarkInReflow();
  DO_GLOBAL_REFLOW_COUNT("nsPluginFrame");
  DISPLAY_REFLOW(aPresContext, this, aReflowInput, aMetrics, aStatus);
  MOZ_ASSERT(aStatus.IsEmpty(), "Caller should pass a fresh reflow status!");

  // Get our desired size
  GetDesiredSize(aPresContext, aReflowInput, aMetrics);
  aMetrics.SetOverflowAreasToDesiredBounds();
  FinishAndStoreOverflow(&aMetrics);

  // delay plugin instantiation until all children have
  // arrived. Otherwise there may be PARAMs or other stuff that the
  // plugin needs to see that haven't arrived yet.
  if (!GetContent()->IsDoneAddingChildren()) {
    return;
  }

  // if we are printing or print previewing, bail for now
  if (aPresContext->Medium() == nsGkAtoms::print) {
    return;
  }

  nsRect r(0, 0, aMetrics.Width(), aMetrics.Height());
  r.Deflate(aReflowInput.ComputedPhysicalBorderPadding());

  if (mInnerView) {
    nsViewManager* vm = mInnerView->GetViewManager();
    vm->MoveViewTo(mInnerView, r.x, r.y);
    vm->ResizeView(mInnerView, nsRect(nsPoint(0, 0), r.Size()), true);
  }

  FixupWindow(r.Size());
  if (!mReflowCallbackPosted) {
    mReflowCallbackPosted = true;
    aPresContext->PresShell()->PostReflowCallback(this);
  }

  NS_FRAME_SET_TRUNCATION(aStatus, aReflowInput, aMetrics);
}

///////////// nsIReflowCallback ///////////////

bool nsPluginFrame::ReflowFinished() {
  mReflowCallbackPosted = false;
  CallSetWindow();
  return true;
}

void nsPluginFrame::ReflowCallbackCanceled() { mReflowCallbackPosted = false; }

void nsPluginFrame::FixupWindow(const nsSize& aSize) {
  nsPresContext* presContext = PresContext();

  if (!mInstanceOwner) return;

  NPWindow* window;
  mInstanceOwner->GetWindow(window);

  NS_ENSURE_TRUE_VOID(window);

  bool windowless = (window->type == NPWindowTypeDrawable);

  nsIntPoint origin = GetWindowOriginInPixels(windowless);

  // window must be in "display pixels"
#if defined(XP_MACOSX)
  // window must be in "display pixels"
  double scaleFactor = 1.0;
  if (NS_FAILED(mInstanceOwner->GetContentsScaleFactor(&scaleFactor))) {
    scaleFactor = 1.0;
  }
  int intScaleFactor = ceil(scaleFactor);
  window->x = origin.x / intScaleFactor;
  window->y = origin.y / intScaleFactor;
  window->width =
      presContext->AppUnitsToDevPixels(aSize.width) / intScaleFactor;
  window->height =
      presContext->AppUnitsToDevPixels(aSize.height) / intScaleFactor;
#else
  window->x = origin.x;
  window->y = origin.y;
  window->width = presContext->AppUnitsToDevPixels(aSize.width);
  window->height = presContext->AppUnitsToDevPixels(aSize.height);
#endif

#ifndef XP_MACOSX
  mInstanceOwner->UpdateWindowPositionAndClipRect(false);
#endif

  NotifyPluginReflowObservers();
}

nsresult nsPluginFrame::CallSetWindow(bool aCheckIsHidden) {
  NPWindow* win = nullptr;

  nsresult rv = NS_ERROR_FAILURE;
  RefPtr<nsNPAPIPluginInstance> pi;
  if (!mInstanceOwner || !(pi = mInstanceOwner->GetInstance()) ||
      NS_FAILED(rv = mInstanceOwner->GetWindow(win)) || !win)
    return rv;

  nsPluginNativeWindow* window = (nsPluginNativeWindow*)win;

  if (aCheckIsHidden && IsHidden()) return NS_ERROR_FAILURE;

  // Calling either nsPluginInstanceOwner::FixUpPluginWindow() (here,
  // on OS X) or SetWindow() (below, on all platforms) can destroy this
  // frame.  (FixUpPluginWindow() calls SetWindow()).  So grab a safe
  // reference to mInstanceOwner which we can use below, if needed.
  RefPtr<nsPluginInstanceOwner> instanceOwnerRef(mInstanceOwner);

  // refresh the plugin port as well
#ifdef XP_MACOSX
  mInstanceOwner->FixUpPluginWindow(nsPluginInstanceOwner::ePluginPaintEnable);
  // Bail now if our frame has been destroyed.
  if (!instanceOwnerRef->GetFrame()) {
    return NS_ERROR_FAILURE;
  }
#endif
  window->window = mInstanceOwner->GetPluginPort();

  // Adjust plugin dimensions according to pixel snap results
  // and reduce amount of SetWindow calls
  nsPresContext* presContext = PresContext();
  nsRootPresContext* rootPC = presContext->GetRootPresContext();
  if (!rootPC) return NS_ERROR_FAILURE;
  int32_t appUnitsPerDevPixel = presContext->AppUnitsPerDevPixel();
  nsIFrame* rootFrame = rootPC->PresShell()->GetRootFrame();
  nsRect bounds =
      GetContentRectRelativeToSelf() + GetOffsetToCrossDoc(rootFrame);
  nsIntRect intBounds = bounds.ToNearestPixels(appUnitsPerDevPixel);

  // In e10s, this returns the offset to the top level window, in non-e10s
  // it return 0,0.
  LayoutDeviceIntPoint intOffset = GetRemoteTabChromeOffset();
  intBounds.x += intOffset.x;
  intBounds.y += intOffset.y;

#if defined(XP_MACOSX)
  // window must be in "display pixels"
  double scaleFactor = 1.0;
  if (NS_FAILED(instanceOwnerRef->GetContentsScaleFactor(&scaleFactor))) {
    scaleFactor = 1.0;
  }

  size_t intScaleFactor = ceil(scaleFactor);
  window->x = intBounds.x / intScaleFactor;
  window->y = intBounds.y / intScaleFactor;
  window->width = intBounds.width / intScaleFactor;
  window->height = intBounds.height / intScaleFactor;
#else
  window->x = intBounds.x;
  window->y = intBounds.y;
  window->width = intBounds.width;
  window->height = intBounds.height;
#endif
  // BE CAREFUL: By the time we get here the PluginFrame is sometimes destroyed
  // and poisoned. If we reference local fields (implicit this deref),
  // we will crash.
  instanceOwnerRef->ResolutionMayHaveChanged();

  // This will call pi->SetWindow and take care of window subclassing
  // if needed, see bug 132759. Calling SetWindow can destroy this frame
  // so check for that before doing anything else with this frame's memory.
  if (instanceOwnerRef->UseAsyncRendering()) {
    rv = pi->AsyncSetWindow(window);
  } else {
    rv = window->CallSetWindow(pi);
  }

  instanceOwnerRef->ReleasePluginPort(window->window);

  return rv;
}

void nsPluginFrame::RegisterPluginForGeometryUpdates() {
  nsRootPresContext* rpc = PresContext()->GetRootPresContext();
  NS_ASSERTION(rpc, "We should have a root pres context!");
  if (mRootPresContextRegisteredWith == rpc || !rpc) {
    // Already registered with current root pres context,
    // or null root pres context...
    return;
  }
  if (mRootPresContextRegisteredWith && mRootPresContextRegisteredWith != rpc) {
    // Registered to some other root pres context. Unregister, and
    // re-register with our current one...
    UnregisterPluginForGeometryUpdates();
  }
  mRootPresContextRegisteredWith = rpc;
  mRootPresContextRegisteredWith->RegisterPluginForGeometryUpdates(mContent);
}

void nsPluginFrame::UnregisterPluginForGeometryUpdates() {
  if (!mRootPresContextRegisteredWith) {
    // Not registered...
    return;
  }
  mRootPresContextRegisteredWith->UnregisterPluginForGeometryUpdates(mContent);
  mRootPresContextRegisteredWith = nullptr;
}

void nsPluginFrame::SetInstanceOwner(nsPluginInstanceOwner* aOwner) {
  // The ownership model here is historically fuzzy. This should only be called
  // by nsPluginInstanceOwner when it is given a new frame, and
  // nsObjectLoadingContent should be arbitrating frame-ownership via its
  // HasNewFrame callback.
  mInstanceOwner = aOwner;

  // Reset the DidCompositeObserver since the owner changed.
  mDidCompositeObserver = nullptr;

  if (mInstanceOwner) {
    return;
  }

  UnregisterPluginForGeometryUpdates();
  if (mWidget && mInnerView) {
    mInnerView->DetachWidgetEventHandler(mWidget);
    // Make sure the plugin is hidden in case an update of plugin geometry
    // hasn't happened since this plugin became hidden.
    nsIWidget* parent = mWidget->GetParent();
    if (parent) {
      nsTArray<nsIWidget::Configuration> configurations;
      nsIWidget::Configuration* configuration = configurations.AppendElement();
      configuration->mChild = mWidget;
      parent->ConfigureChildren(configurations);

      mWidget->Show(false);
      mWidget->Enable(false);
      mWidget->SetParent(nullptr);
    }
  }
}

bool nsPluginFrame::IsHidden(bool aCheckVisibilityStyle) const {
  if (aCheckVisibilityStyle) {
    if (!StyleVisibility()->IsVisibleOrCollapsed()) return true;
  }

  // only <embed> tags support the HIDDEN attribute
  if (mContent->IsHTMLElement(nsGkAtoms::embed)) {
    // Yes, these are really the kooky ways that you could tell 4.x
    // not to hide the <embed> once you'd put the 'hidden' attribute
    // on the tag...

    // HIDDEN w/ no attributes gets translated as we are hidden for
    // compatibility w/ 4.x and IE so we don't create a non-painting
    // widget in layout. See bug 188959.
    nsAutoString hidden;
    if (mContent->AsElement()->GetAttr(kNameSpaceID_None, nsGkAtoms::hidden,
                                       hidden) &&
        (hidden.IsEmpty() || (!hidden.LowerCaseEqualsLiteral("false") &&
                              !hidden.LowerCaseEqualsLiteral("no") &&
                              !hidden.LowerCaseEqualsLiteral("off")))) {
      return true;
    }
  }

  return false;
}

mozilla::LayoutDeviceIntPoint nsPluginFrame::GetRemoteTabChromeOffset() {
  LayoutDeviceIntPoint offset;
  if (XRE_IsContentProcess()) {
    if (nsPIDOMWindowOuter* window = GetContent()->OwnerDoc()->GetWindow()) {
      if (nsCOMPtr<nsPIDOMWindowOuter> topWindow = window->GetInProcessTop()) {
        dom::BrowserChild* tc = dom::BrowserChild::GetFrom(topWindow);
        if (tc) {
          offset += tc->GetChromeOffset();
        }
      }
    }
  }
  return offset;
}

nsIntPoint nsPluginFrame::GetWindowOriginInPixels(bool aWindowless) {
  nsView* parentWithView;
  nsPoint origin(0, 0);

  GetOffsetFromView(origin, &parentWithView);

  // if it's windowless, let's make sure we have our origin set right
  // it may need to be corrected, like after scrolling
  if (aWindowless && parentWithView) {
    nsPoint offsetToWidget;
    parentWithView->GetNearestWidget(&offsetToWidget);
    origin += offsetToWidget;
  }
  origin += GetContentRectRelativeToSelf().TopLeft();

  nsIntPoint pt(PresContext()->AppUnitsToDevPixels(origin.x),
                PresContext()->AppUnitsToDevPixels(origin.y));

  // If we're in the content process offsetToWidget is tied to the top level
  // widget we can access in the child process, which is the tab. We need the
  // offset all the way up to the top level native window here. (If this is
  // non-e10s this routine will return 0,0.)
  if (aWindowless) {
    mozilla::LayoutDeviceIntPoint lpt = GetRemoteTabChromeOffset();
    pt += nsIntPoint(lpt.x, lpt.y);
  }

  return pt;
}

void nsPluginFrame::DidReflow(nsPresContext* aPresContext,
                              const ReflowInput* aReflowInput) {
  // Do this check before calling the superclass, as that clears
  // NS_FRAME_FIRST_REFLOW
  if (HasAnyStateBits(NS_FRAME_FIRST_REFLOW)) {
    nsCOMPtr<nsIObjectLoadingContent> objContent(do_QueryInterface(mContent));
    NS_ASSERTION(objContent, "Why not an object loading content?");
    objContent->HasNewFrame(this);
  }

  nsIFrame::DidReflow(aPresContext, aReflowInput);

  if (HasView()) {
    nsView* view = GetView();
    nsViewManager* vm = view->GetViewManager();
    if (vm)
      vm->SetViewVisibility(
          view, IsHidden() ? nsViewVisibility_kHide : nsViewVisibility_kShow);
  }
}

/* static */
void nsPluginFrame::PaintPrintPlugin(nsIFrame* aFrame, gfxContext* aCtx,
                                     const nsRect& aDirtyRect, nsPoint aPt) {
  // Translate the context:
  nsPoint pt = aPt + aFrame->GetContentRectRelativeToSelf().TopLeft();
  gfxPoint devPixelPt = nsLayoutUtils::PointToGfxPoint(
      pt, aFrame->PresContext()->AppUnitsPerDevPixel());

  gfxContextMatrixAutoSaveRestore autoSR(aCtx);
  aCtx->SetMatrixDouble(aCtx->CurrentMatrixDouble().PreTranslate(devPixelPt));

  // FIXME - Bug 385435: Doesn't aDirtyRect need translating too?

  static_cast<nsPluginFrame*>(aFrame)->PrintPlugin(*aCtx, aDirtyRect);
}

/**
 * nsDisplayPluginReadback creates an active ReadbackLayer. The ReadbackLayer
 * obtains from the compositor the contents of the window underneath
 * the ReadbackLayer, which we then use as an opaque buffer for plugins to
 * asynchronously draw onto.
 */
class nsDisplayPluginReadback : public nsPaintedDisplayItem {
 public:
  nsDisplayPluginReadback(nsDisplayListBuilder* aBuilder, nsIFrame* aFrame)
      : nsPaintedDisplayItem(aBuilder, aFrame) {
    MOZ_COUNT_CTOR(nsDisplayPluginReadback);
  }
#ifdef NS_BUILD_REFCNT_LOGGING
  ~nsDisplayPluginReadback() override {
    MOZ_COUNT_DTOR(nsDisplayPluginReadback);
  }
#endif

  nsRect GetBounds(nsDisplayListBuilder* aBuilder, bool* aSnap) const override;

  NS_DISPLAY_DECL_NAME("PluginReadback", TYPE_PLUGIN_READBACK)

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

  LayerState GetLayerState(
      nsDisplayListBuilder* aBuilder, LayerManager* aManager,
      const ContainerLayerParameters& aParameters) override {
    return LayerState::LAYER_ACTIVE;
  }

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

static nsRect GetDisplayItemBounds(nsDisplayListBuilder* aBuilder,
                                   const nsDisplayItem* aItem,
                                   nsIFrame* aFrame) {
  // XXX For slightly more accurate region computations we should pixel-snap
  // this
  return aFrame->GetContentRectRelativeToSelf() + aItem->ToReferenceFrame();
}

nsRect nsDisplayPluginReadback::GetBounds(nsDisplayListBuilder* aBuilder,
                                          bool* aSnap) const {
  *aSnap = false;
  return GetDisplayItemBounds(aBuilder, this, mFrame);
}

nsRect nsDisplayPlugin::GetBounds(nsDisplayListBuilder* aBuilder,
                                  bool* aSnap) const {
  *aSnap = true;
  return GetDisplayItemBounds(aBuilder, this, mFrame);
}

void nsDisplayPlugin::Paint(nsDisplayListBuilder* aBuilder, gfxContext* aCtx) {
  nsPluginFrame* f = static_cast<nsPluginFrame*>(mFrame);
  bool snap;
  f->PaintPlugin(aBuilder, *aCtx, GetPaintRect(), GetBounds(aBuilder, &snap));
}

static nsRect GetClippedBoundsIncludingAllScrollClips(
    nsDisplayItem* aItem, nsDisplayListBuilder* aBuilder) {
  nsRect r = aItem->GetClippedBounds(aBuilder);
  for (auto* sc = aItem->GetClipChain(); sc; sc = sc->mParent) {
    r = sc->mClip.ApplyNonRoundedIntersection(r);
  }
  return r;
}

bool nsDisplayPlugin::ComputeVisibility(nsDisplayListBuilder* aBuilder,
                                        nsRegion* aVisibleRegion) {
  if (aBuilder->IsForPluginGeometry()) {
    nsPluginFrame* f = static_cast<nsPluginFrame*>(mFrame);
    if (!aBuilder->IsInTransform() || f->IsPaintedByGecko()) {
      // Since transforms induce reference frames, we don't need to worry
      // about this method fluffing out due to non-rectilinear transforms.
      nsRect rAncestor = nsLayoutUtils::TransformFrameRectToAncestor(
          f, f->GetContentRectRelativeToSelf(), ReferenceFrame());
      nscoord appUnitsPerDevPixel =
          ReferenceFrame()->PresContext()->AppUnitsPerDevPixel();
      f->mNextConfigurationBounds = LayoutDeviceIntRect::FromUnknownRect(
          rAncestor.ToNearestPixels(appUnitsPerDevPixel));

      nsRegion visibleRegion;
      // Apply all scroll clips when computing the clipped bounds of this item.
      // We hide windowed plugins during APZ scrolling, so there never is an
      // async transform that we need to take into account when clipping.
      visibleRegion.And(
          *aVisibleRegion,
          GetClippedBoundsIncludingAllScrollClips(this, aBuilder));
      // Make visibleRegion relative to f
      visibleRegion.MoveBy(-ToReferenceFrame());

      f->mNextConfigurationClipRegion.Clear();
      for (auto iter = visibleRegion.RectIter(); !iter.Done(); iter.Next()) {
        nsRect rAncestor = nsLayoutUtils::TransformFrameRectToAncestor(
            f, iter.Get(), ReferenceFrame());
        LayoutDeviceIntRect rPixels =
            LayoutDeviceIntRect::FromUnknownRect(
                rAncestor.ToNearestPixels(appUnitsPerDevPixel)) -
            f->mNextConfigurationBounds.TopLeft();
        if (!rPixels.IsEmpty()) {
          f->mNextConfigurationClipRegion.AppendElement(rPixels);
        }
      }
    }

    if (f->mInnerView) {
      // This should produce basically the same rectangle (but not relative
      // to the root frame). We only call this here for the side-effect of
      // setting mViewToWidgetOffset on the view.
      f->mInnerView->CalcWidgetBounds(eWindowType_plugin);
    }
  }

  return nsDisplayItem::ComputeVisibility(aBuilder, aVisibleRegion);
}

nsRegion nsDisplayPlugin::GetOpaqueRegion(nsDisplayListBuilder* aBuilder,
                                          bool* aSnap) const {
  *aSnap = false;
  nsRegion result;
  nsPluginFrame* f = static_cast<nsPluginFrame*>(mFrame);
  if (!aBuilder->IsForPluginGeometry()) {
    nsIWidget* widget = f->GetWidget();
    if (widget) {
      // Be conservative and treat plugins with widgets as not opaque,
      // because that's simple and we might need the content under the widget
      // if the widget is unexpectedly clipped away. (As can happen when
      // chrome content over a plugin forces us to clip out the plugin for
      // security reasons.)
      // We shouldn't be repainting the content under plugins much anyway
      // since there generally shouldn't be anything to invalidate or paint
      // in PaintedLayers there.
      return result;
    }
  }

  if (f->IsOpaque()) {
    nsRect bounds = GetBounds(aBuilder, aSnap);
    if (aBuilder->IsForPluginGeometry() ||
        (f->GetPaintedRect(this) + ToReferenceFrame()).Contains(bounds)) {
      // We can treat this as opaque
      result = bounds;
    }
  }

  return result;
}

bool nsDisplayPlugin::CreateWebRenderCommands(
    mozilla::wr::DisplayListBuilder& aBuilder,
    mozilla::wr::IpcResourceUpdateQueue& aResources,
    const StackingContextHelper& aSc,
    mozilla::layers::RenderRootStateManager* aManager,
    nsDisplayListBuilder* aDisplayListBuilder) {
  return static_cast<nsPluginFrame*>(mFrame)->CreateWebRenderCommands(
      this, aBuilder, aResources, aSc, aManager, aDisplayListBuilder);
}

nsresult nsPluginFrame::PluginEventNotifier::Run() {
  nsCOMPtr<nsIObserverService> obsSvc = mozilla::services::GetObserverService();
  obsSvc->NotifyObservers(nullptr, "plugin-changed-event", mEventType.get());
  return NS_OK;
}

void nsPluginFrame::NotifyPluginReflowObservers() {
  nsContentUtils::AddScriptRunner(new PluginEventNotifier(u"reflow"_ns));
}

void nsPluginFrame::DidSetWidgetGeometry() {
#if defined(XP_MACOSX)
  if (mInstanceOwner && !IsHidden()) {
    mInstanceOwner->FixUpPluginWindow(
        nsPluginInstanceOwner::ePluginPaintEnable);
  }
#else
  if (!mWidget && mInstanceOwner) {
    // UpdateWindowVisibility will notify the plugin of position changes
    // by updating the NPWindow and calling NPP_SetWindow/AsyncSetWindow.
    // We treat windowless plugins inside popups as always visible, since
    // plugins inside popups don't get valid mNextConfigurationBounds
    // set up.
    mInstanceOwner->UpdateWindowVisibility(
        nsLayoutUtils::IsPopup(nsLayoutUtils::GetDisplayRootFrame(this)) ||
        !mNextConfigurationBounds.IsEmpty());
  }
#endif
}

bool nsPluginFrame::IsOpaque() const {
#if defined(XP_MACOSX)
  return false;
#else

  if (mInstanceOwner && mInstanceOwner->UseAsyncRendering()) {
    return false;
  }
  return !IsTransparentMode();
#endif
}

bool nsPluginFrame::IsTransparentMode() const {
#if defined(XP_MACOSX)
  return false;
#else
  if (!mInstanceOwner) return false;

  NPWindow* window = nullptr;
  mInstanceOwner->GetWindow(window);
  if (!window) {
    return false;
  }

  if (window->type != NPWindowTypeDrawable) return false;

  RefPtr<nsNPAPIPluginInstance> pi = mInstanceOwner->GetInstance();
  if (!pi) {
    return false;
  }

  bool transparent = false;
  pi->IsTransparent(&transparent);
  return transparent;
#endif
}

void nsPluginFrame::BuildDisplayList(nsDisplayListBuilder* aBuilder,
                                     const nsDisplayListSet& aLists) {
  // XXX why are we painting collapsed object frames?
  if (!IsVisibleOrCollapsedForPainting()) return;

  DisplayBorderBackgroundOutline(aBuilder, aLists);

  nsPresContext::nsPresContextType type = PresContext()->Type();

  // If we are painting in Print Preview do nothing....
  if (type == nsPresContext::eContext_PrintPreview) return;

  DO_GLOBAL_REFLOW_COUNT_DSP("nsPluginFrame");

#ifndef XP_MACOSX
  if (mWidget && aBuilder->IsInTransform()) {
    // Windowed plugins should not be rendered inside a transform.
    return;
  }
#endif

  if (aBuilder->IsForPainting() && mInstanceOwner) {
    // Update plugin frame for both content scaling and full zoom changes.
    mInstanceOwner->ResolutionMayHaveChanged();
#ifdef XP_MACOSX
    mInstanceOwner->WindowFocusMayHaveChanged();
#endif
    if (mInstanceOwner->UseAsyncRendering()) {
      NPWindow* window = nullptr;
      mInstanceOwner->GetWindow(window);
      bool isVisible = window && window->width > 0 && window->height > 0;
      if (isVisible && aBuilder->ShouldSyncDecodeImages()) {
#ifndef XP_MACOSX
        mInstanceOwner->UpdateWindowVisibility(true);
#endif
      }

      mInstanceOwner->NotifyPaintWaiter(aBuilder);
    }
  }

  DisplayListClipState::AutoClipContainingBlockDescendantsToContentBox clip(
      aBuilder, this);

  // determine if we are printing
  if (type == nsPresContext::eContext_Print) {
    aLists.Content()->AppendNewToTop<nsDisplayGeneric>(
        aBuilder, this, PaintPrintPlugin, "PrintPlugin",
        DisplayItemType::TYPE_PRINT_PLUGIN);
  } else {
    LayerState state = GetLayerState(aBuilder, nullptr);
    if (state == LayerState::LAYER_INACTIVE &&
        nsDisplayItem::ForceActiveLayers()) {
      state = LayerState::LAYER_ACTIVE;
    }
    if (aBuilder->IsPaintingToWindow() && state == LayerState::LAYER_ACTIVE &&
        IsTransparentMode()) {
      aLists.Content()->AppendNewToTop<nsDisplayPluginReadback>(aBuilder, this);
    }

    aLists.Content()->AppendNewToTop<nsDisplayPlugin>(aBuilder, this);
  }
}

void nsPluginFrame::PrintPlugin(gfxContext& aRenderingContext,
                                const nsRect& aDirtyRect) {
  nsCOMPtr<nsIObjectLoadingContent> obj(do_QueryInterface(mContent));
  if (!obj) return;

  nsIFrame* frame = nullptr;
  obj->GetPrintFrame(&frame);
  if (!frame) return;

  nsPresContext* presContext = PresContext();
  // make sure this is REALLY an nsIObjectFrame
  // we may need to go through the children to get it
  nsIObjectFrame* objectFrame = do_QueryFrame(frame);
  if (!objectFrame) objectFrame = GetNextObjectFrame(presContext, frame);
  if (!objectFrame) return;

  // finally we can get our plugin instance
  RefPtr<nsNPAPIPluginInstance> pi = objectFrame->GetPluginInstance();
  if (!pi) {
    return;
  }

  // now we need to setup the correct location for printing
  NPWindow window;
  window.window = nullptr;

  // prepare embedded mode printing struct
  NPPrint npprint;
  npprint.mode = NP_EMBED;

  // we need to find out if we are windowless or not
  bool windowless = false;
  pi->IsWindowless(&windowless);
  window.type = windowless ? NPWindowTypeDrawable : NPWindowTypeWindow;

  window.clipRect.bottom = 0;
  window.clipRect.top = 0;
  window.clipRect.left = 0;
  window.clipRect.right = 0;

// platform specific printing code
#if defined(XP_UNIX) || defined(XP_MACOSX)
  // Doesn't work in a thebes world, or on OS X.
  (void)window;
  (void)npprint;
#elif defined(XP_WIN)

  /* On Windows, we use the win32 printing surface to print.  This, in
   * turn, uses the Cairo paginated surface, which in turn uses the
   * meta surface to record all operations and then play them back.
   * This doesn't work too well for plugins, because if plugins render
   * directly into the DC, the meta surface won't have any knowledge
   * of them, and so at the end when it actually does the replay step,
   * it'll fill the background with white and draw over whatever was
   * rendered before.
   *
   * So, to avoid this, we use PushGroup, which creates a new windows
   * surface, the plugin renders to that, and then we use normal
   * cairo methods to composite that in such that it's recorded using the
   * meta surface.
   */

  // we'll already be translated into the right spot by gfxWindowsNativeDrawing
  nsSize contentSize = GetContentRectRelativeToSelf().Size();
  window.x = 0;
  window.y = 0;
  window.width = presContext->AppUnitsToDevPixels(contentSize.width);
  window.height = presContext->AppUnitsToDevPixels(contentSize.height);

  aRenderingContext.Save();

  // Make sure plugins don't do any damage outside of where they're supposed to
  aRenderingContext.NewPath();
  gfxRect r(window.x, window.y, window.width, window.height);
  aRenderingContext.Rectangle(r);
  aRenderingContext.Clip();

  gfxWindowsNativeDrawing nativeDraw(&aRenderingContext, r);
  do {
    HDC dc = nativeDraw.BeginNativeDrawing();
    if (!dc) return;

    // XXX don't we need to call nativeDraw.TransformToNativeRect here?
    npprint.print.embedPrint.platformPrint = dc;
    npprint.print.embedPrint.window = window;
    // send off print info to plugin
    pi->Print(&npprint);

    nativeDraw.EndNativeDrawing();
  } while (nativeDraw.ShouldRenderAgain());
  nativeDraw.PaintToContext();

  aRenderingContext.Restore();
#endif

  // XXX Nav 4.x always sent a SetWindow call after print. Should we do the
  // same?
  // XXX Calling DidReflow here makes no sense!!!
  frame->DidReflow(presContext, nullptr);  // DidReflow will take care of it
}

nsRect nsPluginFrame::GetPaintedRect(const nsDisplayPlugin* aItem) const {
  if (!mInstanceOwner) return nsRect();
  nsRect r = GetContentRectRelativeToSelf();
  if (!mInstanceOwner->UseAsyncRendering()) return r;

  nsIntSize size = mInstanceOwner->GetCurrentImageSize();
  nsPresContext* pc = PresContext();
  r.IntersectRect(r, nsRect(0, 0, pc->DevPixelsToAppUnits(size.width),
                            pc->DevPixelsToAppUnits(size.height)));
  return r;
}

LayerState nsPluginFrame::GetLayerState(nsDisplayListBuilder* aBuilder,
                                        LayerManager* aManager) {
  if (!mInstanceOwner) return LayerState::LAYER_NONE;

  if (mInstanceOwner->NeedsScrollImageLayer()) {
    return LayerState::LAYER_ACTIVE;
  }

  if (!mInstanceOwner->UseAsyncRendering()) {
    return LayerState::LAYER_NONE;
  }

  return LayerState::LAYER_ACTIVE_FORCE;
}

class PluginFrameDidCompositeObserver final : public DidCompositeObserver {
 public:
  PluginFrameDidCompositeObserver(nsPluginInstanceOwner* aOwner,
                                  LayerManager* aLayerManager)
      : mInstanceOwner(aOwner), mLayerManager(aLayerManager) {}
  ~PluginFrameDidCompositeObserver() {
    mLayerManager->RemoveDidCompositeObserver(this);
  }
  void DidComposite() override { mInstanceOwner->DidComposite(); }
  bool IsValid(LayerManager* aLayerManager) {
    return aLayerManager == mLayerManager;
  }

 private:
  nsPluginInstanceOwner* mInstanceOwner;
  RefPtr<LayerManager> mLayerManager;
};

bool nsPluginFrame::GetBounds(nsDisplayItem* aItem, IntSize& aSize,
                              gfxRect& aRect) {
  if (!mInstanceOwner) return false;

  NPWindow* window = nullptr;
  mInstanceOwner->GetWindow(window);
  if (!window) return false;

  if (window->width <= 0 || window->height <= 0) return false;

#if defined(XP_MACOSX)
  // window is in "display pixels", but size needs to be in device pixels
  // window must be in "display pixels"
  double scaleFactor = 1.0;
  if (NS_FAILED(mInstanceOwner->GetContentsScaleFactor(&scaleFactor))) {
    scaleFactor = 1.0;
  }

  size_t intScaleFactor = ceil(scaleFactor);
#else
  size_t intScaleFactor = 1;
#endif

  aSize =
      IntSize(window->width * intScaleFactor, window->height * intScaleFactor);

  nsRect area = GetContentRectRelativeToSelf() + aItem->ToReferenceFrame();
  aRect =
      nsLayoutUtils::RectToGfxRect(area, PresContext()->AppUnitsPerDevPixel());
  // to provide crisper and faster drawing.
  aRect.Round();

  return true;
}

bool nsPluginFrame::CreateWebRenderCommands(
    nsDisplayItem* aItem, mozilla::wr::DisplayListBuilder& aBuilder,
    mozilla::wr::IpcResourceUpdateQueue& aResources,
    const StackingContextHelper& aSc,
    mozilla::layers::RenderRootStateManager* aManager,
    nsDisplayListBuilder* aDisplayListBuilder) {
  IntSize size;
  gfxRect r;
  if (!GetBounds(aItem, size, r)) {
    return true;
  }

  RefPtr<ImageContainer> container;
  // Image for Windowed plugins that support window capturing for scroll
  // operations or async windowless rendering.
  container = mInstanceOwner->GetImageContainer();
  if (!container) {
    // This can occur if our instance is gone or if the current plugin
    // configuration does not require a backing image layer.
    return true;
  }

#ifdef XP_MACOSX
  if (!mInstanceOwner->UseAsyncRendering()) {
    mInstanceOwner->DoCocoaEventDrawRect(r, nullptr);
  }
#endif

  RefPtr<LayerManager> lm = aDisplayListBuilder->GetWidgetLayerManager();
  if (!mDidCompositeObserver || !mDidCompositeObserver->IsValid(lm)) {
    mDidCompositeObserver =
        MakeUnique<PluginFrameDidCompositeObserver>(mInstanceOwner, lm);
  }
  lm->AddDidCompositeObserver(mDidCompositeObserver.get());

  // If the image container is empty, we don't want to fallback. Any other
  // failure will be due to resource constraints and fallback is unlikely to
  // help us. Hence we can ignore the return value from PushImage.
  LayoutDeviceRect dest(r.x, r.y, size.width, size.height);
  aManager->CommandBuilder().PushImage(aItem, container, aBuilder, aResources,
                                       aSc, dest, dest);
  return true;
}

already_AddRefed<Layer> nsPluginFrame::BuildLayer(
    nsDisplayListBuilder* aBuilder, LayerManager* aManager,
    nsDisplayItem* aItem,
    const ContainerLayerParameters& aContainerParameters) {
  IntSize size;
  gfxRect r;
  if (!GetBounds(aItem, size, r)) {
    return nullptr;
  }

  RefPtr<Layer> layer =
      (aManager->GetLayerBuilder()->GetLeafLayerFor(aBuilder, aItem));

  if (aItem->GetType() == DisplayItemType::TYPE_PLUGIN) {
    RefPtr<ImageContainer> container;
    // Image for Windowed plugins that support window capturing for scroll
    // operations or async windowless rendering.
    container = mInstanceOwner->GetImageContainer();
    if (!container) {
      // This can occur if our instance is gone or if the current plugin
      // configuration does not require a backing image layer.
      return nullptr;
    }

    if (!layer) {
      mInstanceOwner->NotifyPaintWaiter(aBuilder);
      // Initialize ImageLayer
      layer = aManager->CreateImageLayer();
      if (!layer) return nullptr;
    }

    NS_ASSERTION(layer->GetType() == Layer::TYPE_IMAGE, "Bad layer type");
    ImageLayer* imglayer = static_cast<ImageLayer*>(layer.get());
#ifdef XP_MACOSX
    if (!mInstanceOwner->UseAsyncRendering()) {
      mInstanceOwner->DoCocoaEventDrawRect(r, nullptr);
    }
#endif

    imglayer->SetScaleToSize(size, ScaleMode::STRETCH);
    imglayer->SetContainer(container);
    SamplingFilter samplingFilter =
        nsLayoutUtils::GetSamplingFilterForFrame(this);
#ifdef MOZ_GFX_OPTIMIZE_MOBILE
    if (!aManager->IsCompositingCheap()) {
      // Pixman just horrible with bilinear filter scaling
      samplingFilter = SamplingFilter::POINT;
    }
#endif
    imglayer->SetSamplingFilter(samplingFilter);

    layer->SetContentFlags(IsOpaque() ? Layer::CONTENT_OPAQUE : 0);

    if (aBuilder->IsPaintingToWindow() && aBuilder->GetWidgetLayerManager() &&
        (aBuilder->GetWidgetLayerManager()->GetBackendType() ==
             LayersBackend::LAYERS_CLIENT ||
         aBuilder->GetWidgetLayerManager()->GetBackendType() ==
             LayersBackend::LAYERS_WR) &&
        mInstanceOwner->UseAsyncRendering()) {
      RefPtr<LayerManager> lm = aBuilder->GetWidgetLayerManager();
      if (!mDidCompositeObserver || !mDidCompositeObserver->IsValid(lm)) {
        mDidCompositeObserver =
            MakeUnique<PluginFrameDidCompositeObserver>(mInstanceOwner, lm);
      }
      lm->AddDidCompositeObserver(mDidCompositeObserver.get());
    }
  } else {
    NS_ASSERTION(aItem->GetType() == DisplayItemType::TYPE_PLUGIN_READBACK,
                 "Unknown item type");
    MOZ_ASSERT(!IsOpaque(), "Opaque plugins don't use backgrounds");

    if (!layer) {
      layer = aManager->CreateReadbackLayer();
      if (!layer) return nullptr;
    }
    NS_ASSERTION(layer->GetType() == Layer::TYPE_READBACK, "Bad layer type");

    ReadbackLayer* readback = static_cast<ReadbackLayer*>(layer.get());
    if (readback->GetSize() != size) {
      // This will destroy any old background sink and notify us that the
      // background is now unknown
      readback->SetSink(nullptr);
      readback->SetSize(size);

      if (mBackgroundSink) {
        // Maybe we still have a background sink associated with another
        // readback layer that wasn't recycled for some reason? Unhook it
        // now so that if this frame goes away, it doesn't have a dangling
        // reference to us.
        mBackgroundSink->Destroy();
      }
      mBackgroundSink =
          new PluginBackgroundSink(this, readback->AllocateSequenceNumber());
      readback->SetSink(mBackgroundSink);
      // The layer has taken ownership of our sink. When either the sink dies
      // or the frame dies, the connection from the surviving object is nulled
      // out.
    }
  }

  // Set a transform on the layer to draw the plugin in the right place
  gfxPoint p = r.TopLeft() + aContainerParameters.mOffset;
  Matrix transform = Matrix::Translation(p.x, p.y);

  layer->SetBaseTransform(Matrix4x4::From2D(transform));
  return layer.forget();
}

void nsPluginFrame::PaintPlugin(nsDisplayListBuilder* aBuilder,
                                gfxContext& aRenderingContext,
                                const nsRect& aDirtyRect,
                                const nsRect& aPluginRect) {
#if defined(DEBUG)
  // On Desktop, we should have built a layer as we no longer support in-process
  // plugins or synchronous painting. We can only get here for windowed plugins
  // (which draw themselves), or via some error/unload state.
  if (mInstanceOwner) {
    NPWindow* window = nullptr;
    mInstanceOwner->GetWindow(window);
    MOZ_ASSERT(!window || window->type == NPWindowTypeWindow);
  }
#endif
}

nsresult nsPluginFrame::HandleEvent(nsPresContext* aPresContext,
                                    WidgetGUIEvent* anEvent,
                                    nsEventStatus* anEventStatus) {
  NS_ENSURE_ARG_POINTER(anEvent);
  NS_ENSURE_ARG_POINTER(anEventStatus);
  nsresult rv = NS_OK;

  if (!mInstanceOwner) return NS_ERROR_NULL_POINTER;

  mInstanceOwner->ConsiderNewEventloopNestingLevel();

  if (anEvent->mMessage == ePluginActivate) {
    if (RefPtr<nsFocusManager> fm = nsFocusManager::GetFocusManager()) {
      RefPtr<dom::Element> elem = GetContent()->AsElement();
      return fm->SetFocus(elem, 0);
    }
  } else if (anEvent->mMessage == ePluginFocus) {
    if (RefPtr<nsFocusManager> fm = nsFocusManager::GetFocusManager()) {
      RefPtr<dom::Element> elem = GetContent()->AsElement();
      return fm->FocusPlugin(elem);
    }
  }

#ifdef XP_WIN
  rv = nsIFrame::HandleEvent(aPresContext, anEvent, anEventStatus);
  return rv;
#endif

#ifdef XP_MACOSX
  // we want to process some native mouse events in the cocoa event model
  if ((anEvent->mMessage == eMouseEnterIntoWidget ||
       anEvent->mMessage == eWheel) &&
      mInstanceOwner->GetEventModel() == NPEventModelCocoa) {
    *anEventStatus = mInstanceOwner->ProcessEvent(*anEvent);
    // Due to plugin code reentering Gecko, this frame may be dead at this
    // point.
    return rv;
  }

  // These two calls to PresShell::SetCapturingContent() (on mouse-down
  // and mouse-up) are needed to make the routing of mouse events while
  // dragging conform to standard OS X practice, and to the Cocoa NPAPI spec.
  // See bug 525078 and bug 909678.
  if (anEvent->mMessage == eMouseDown) {
    PresShell::SetCapturingContent(GetContent(),
                                   CaptureFlags::IgnoreAllowedState);
  }
#endif

  rv = nsIFrame::HandleEvent(aPresContext, anEvent, anEventStatus);

  // We need to be careful from this point because the call to
  // nsIFrame::HandleEvent() might have killed us.

#ifdef XP_MACOSX
  if (anEvent->mMessage == eMouseUp) {
    PresShell::ReleaseCapturingContent();
  }
#endif

  return rv;
}

void nsPluginFrame::HandleWheelEventAsDefaultAction(
    WidgetWheelEvent* aWheelEvent) {
  MOZ_ASSERT(WantsToHandleWheelEventAsDefaultAction());
  MOZ_ASSERT(!aWheelEvent->DefaultPrevented());

  if (NS_WARN_IF(!mInstanceOwner) ||
      NS_WARN_IF(aWheelEvent->mMessage != eWheel)) {
    return;
  }

  // If the wheel event has native message, it should may be handled by
  // HandleEvent() in the future.  In such case, we should do nothing here.
  if (NS_WARN_IF(!!aWheelEvent->mPluginEvent)) {
    return;
  }

  mInstanceOwner->ProcessEvent(*aWheelEvent);
  // We need to assume that the event is always consumed/handled by the
  // plugin.  There is no way to know if it's actually consumed/handled.
  aWheelEvent->mViewPortIsOverscrolled = false;
  aWheelEvent->mOverflowDeltaX = 0;
  aWheelEvent->mOverflowDeltaY = 0;
  // Consume the event explicitly.
  aWheelEvent->PreventDefault();
}

bool nsPluginFrame::WantsToHandleWheelEventAsDefaultAction() const {
#ifdef XP_WIN
  if (!mInstanceOwner) {
    return false;
  }
  NPWindow* window = nullptr;
  mInstanceOwner->GetWindow(window);
  // On Windows, only when the plugin is windowless, we need to send wheel
  // events as default action.
  return window->type == NPWindowTypeDrawable;
#else
  return false;
#endif
}

nsNPAPIPluginInstance* nsPluginFrame::GetPluginInstance() {
  if (!mInstanceOwner) {
    return nullptr;
  }

  return mInstanceOwner->GetInstance();
}

Maybe<nsIFrame::Cursor> nsPluginFrame::GetCursor(const nsPoint& aPoint) {
  if (!mInstanceOwner) {
    return Nothing();
  }

  RefPtr<nsNPAPIPluginInstance> inst = mInstanceOwner->GetInstance();
  if (!inst) {
    return Nothing();
  }

  bool useDOMCursor =
      static_cast<nsNPAPIPluginInstance*>(inst.get())->UsesDOMForCursor();
  if (!useDOMCursor) {
    return Nothing();
  }

  return nsIFrame::GetCursor(aPoint);
}

void nsPluginFrame::SetIsDocumentActive(bool aIsActive) {
  if (mInstanceOwner) {
    mInstanceOwner->UpdateDocumentActiveState(aIsActive);
  }
}

// static
nsIObjectFrame* nsPluginFrame::GetNextObjectFrame(nsPresContext* aPresContext,
                                                  nsIFrame* aRoot) {
  for (nsIFrame* child : aRoot->PrincipalChildList()) {
    nsIObjectFrame* outFrame = do_QueryFrame(child);
    if (outFrame) {
      if (outFrame->GetPluginInstance()) {  // make sure we have a REAL plugin
        return outFrame;
      }
    }

    outFrame = GetNextObjectFrame(aPresContext, child);
    if (outFrame) return outFrame;
  }

  return nullptr;
}

/*static*/
void nsPluginFrame::BeginSwapDocShells(nsISupports* aSupports) {
  MOZ_ASSERT(aSupports, "null parameter");
  nsCOMPtr<nsIContent> content(do_QueryInterface(aSupports));
  if (!content) {
    return;
  }

  // This function is called from a document content enumerator so we need
  // to filter out the nsPluginFrames and ignore the rest.
  nsIObjectFrame* obj = do_QueryFrame(content->GetPrimaryFrame());
  if (!obj) return;

  nsPluginFrame* objectFrame = static_cast<nsPluginFrame*>(obj);
  NS_ASSERTION(!objectFrame->mWidget || objectFrame->mWidget->GetParent(),
               "Plugin windows must not be toplevel");
  objectFrame->UnregisterPluginForGeometryUpdates();
}

/*static*/
void nsPluginFrame::EndSwapDocShells(nsISupports* aSupports) {
  MOZ_ASSERT(aSupports, "null parameter");
  nsCOMPtr<nsIContent> content(do_QueryInterface(aSupports));
  if (!content) {
    return;
  }

  // This function is called from a document content enumerator so we need
  // to filter out the nsPluginFrames and ignore the rest.
  nsIObjectFrame* obj = do_QueryFrame(content->GetPrimaryFrame());
  if (!obj) return;

  nsPluginFrame* objectFrame = static_cast<nsPluginFrame*>(obj);
  nsRootPresContext* rootPC = objectFrame->PresContext()->GetRootPresContext();
  NS_ASSERTION(rootPC, "unable to register the plugin frame");
  nsIWidget* widget = objectFrame->mWidget;
  if (widget) {
    // Reparent the widget.
    nsIWidget* parent = rootPC->PresShell()->GetRootFrame()->GetNearestWidget();
    widget->SetParent(parent);
    AutoWeakFrame weakFrame(objectFrame);
    objectFrame->CallSetWindow();
    if (!weakFrame.IsAlive()) {
      return;
    }
  }

  if (objectFrame->mInstanceOwner) {
    objectFrame->RegisterPluginForGeometryUpdates();
  }
}

nsIFrame* NS_NewObjectFrame(PresShell* aPresShell, ComputedStyle* aStyle) {
  return new (aPresShell) nsPluginFrame(aStyle, aPresShell->GetPresContext());
}

bool nsPluginFrame::IsPaintedByGecko() const {
#ifdef XP_MACOSX
  return true;
#else
  return !mWidget;
#endif
}

NS_IMPL_FRAMEARENA_HELPERS(nsPluginFrame)