/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */

// vim:set ts=2 sts=2 sw=2 et cin:

/* 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/. */

#ifndef nsPluginInstanceOwner_h_

#define nsPluginInstanceOwner_h_

#include "mozilla/Attributes.h"

#include "mozilla/StaticPtr.h"

#include "npapi.h"

#include "nsCOMPtr.h"

#include "nsIKeyEventInPluginCallback.h"

#include "nsIPluginInstanceOwner.h"

#include "nsIPrivacyTransitionObserver.h"

#include "nsIDOMEventListener.h"

#include "nsPluginHost.h"

#include "nsPluginNativeWindow.h"

#include "nsWeakReference.h"

#include "gfxRect.h"

#ifdef XP_MACOSX

#include "mozilla/gfx/QuartzSupport.h"

#include <ApplicationServices/ApplicationServices.h>

#endif

class nsIInputStream;

class nsPluginDOMContextMenuListener;

class nsPluginFrame;

class nsDisplayListBuilder;

#if defined(MOZ_X11)

class gfxContext;

#endif

namespace mozilla {

class TextComposition;

namespace dom {

class Element;

class Event;

struct MozPluginParameter;

} // namespace dom

namespace widget {

class PuppetWidget;

} // namespace widget

} // namespace mozilla

using mozilla::widget::PuppetWidget;

#ifdef MOZ_X11

#include "gfxXlibNativeRenderer.h"

#endif

class nsPluginInstanceOwner final : public nsIPluginInstanceOwner

                                  , public nsIDOMEventListener

                                  , public nsIPrivacyTransitionObserver

                                  , public nsIKeyEventInPluginCallback

                                  , public nsSupportsWeakReference

{

public:

  typedef mozilla::gfx::DrawTarget DrawTarget;

  nsPluginInstanceOwner();

  NS_DECL_ISUPPORTS

  NS_DECL_NSIPLUGININSTANCEOWNER

  NS_DECL_NSIPRIVACYTRANSITIONOBSERVER

  NS_IMETHOD GetURL(const char *aURL, const char *aTarget,

                    nsIInputStream *aPostStream,

                    void *aHeadersData, uint32_t aHeadersDataLen,

                    bool aDoCheckLoadURIChecks) override;

  NPBool     ConvertPoint(double sourceX, double sourceY, NPCoordinateSpace sourceSpace,

                          double *destX, double *destY, NPCoordinateSpace destSpace) override;

  NPError InitAsyncSurface(NPSize *size, NPImageFormat format,

                           void *initData, NPAsyncSurface *surface) override;

  NPError FinalizeAsyncSurface(NPAsyncSurface *surface) override;

  void SetCurrentAsyncSurface(NPAsyncSurface *surface, NPRect *changed) override;

  /**

   * Get the type of the HTML tag that was used ot instantiate this

   * plugin.  Currently supported tags are EMBED or OBJECT.

   */

  NS_IMETHOD GetTagType(nsPluginTagType *aResult);

  void GetParameters(nsTArray<mozilla::dom::MozPluginParameter>& parameters);

  void GetAttributes(nsTArray<mozilla::dom::MozPluginParameter>& attributes);

  /**

   * Returns the DOM element corresponding to the tag which references

   * this plugin in the document.

   *

   * @param aDOMElement - resulting DOM element

   * @result - NS_OK if this operation was successful

   */

  NS_IMETHOD GetDOMElement(mozilla::dom::Element** aResult);

  // nsIDOMEventListener interfaces

  NS_DECL_NSIDOMEVENTLISTENER

  nsresult ProcessMouseDown(mozilla::dom::Event* aMouseEvent);

  nsresult ProcessKeyPress(mozilla::dom::Event* aKeyEvent);

  nsresult Destroy();

#ifdef XP_WIN

  void Paint(const RECT& aDirty, HDC aDC);

#elif defined(XP_MACOSX)

  void Paint(const gfxRect& aDirtyRect, CGContextRef cgContext);

  void RenderCoreAnimation(CGContextRef aCGContext, int aWidth, int aHeight);

  void DoCocoaEventDrawRect(const gfxRect& aDrawRect, CGContextRef cgContext);

#elif defined(MOZ_X11)

  void Paint(gfxContext* aContext,

             const gfxRect& aFrameRect,

             const gfxRect& aDirtyRect);

#endif

  //locals

  nsresult Init(nsIContent* aContent);

  void* GetPluginPort();

  void ReleasePluginPort(void* pluginPort);

  nsEventStatus ProcessEvent(const mozilla::WidgetGUIEvent& anEvent);

  static void GeneratePluginEvent(

                const mozilla::WidgetCompositionEvent* aSrcCompositionEvent,

                mozilla::WidgetCompositionEvent* aDistCompositionEvent);

#if defined(XP_WIN)

  void SetWidgetWindowAsParent(HWND aWindowToAdopt);

  nsresult SetNetscapeWindowAsParent(HWND aWindowToAdopt);

#endif

#ifdef XP_MACOSX

  enum { ePluginPaintEnable, ePluginPaintDisable };

  void WindowFocusMayHaveChanged();

  bool WindowIsActive();

  void SendWindowFocusChanged(bool aIsActive);

  NPDrawingModel GetDrawingModel();

  bool IsRemoteDrawingCoreAnimation();

  NPEventModel GetEventModel();

  static void CARefresh(nsITimer *aTimer, void *aClosure);

  void AddToCARefreshTimer();

  void RemoveFromCARefreshTimer();

  // This calls into the plugin (NPP_SetWindow) and can run script.

  void FixUpPluginWindow(int32_t inPaintState);

  void HidePluginWindow();

  // Set plugin port info in the plugin (in the 'window' member of the

  // NPWindow structure passed to the plugin by SetWindow()).

  void SetPluginPort();

#else // XP_MACOSX

  void UpdateWindowPositionAndClipRect(bool aSetWindow);

  void UpdateWindowVisibility(bool aVisible);

#endif // XP_MACOSX

  void ResolutionMayHaveChanged();

#if defined(XP_MACOSX) || defined(XP_WIN)

  nsresult ContentsScaleFactorChanged(double aContentsScaleFactor);

#endif

  void UpdateDocumentActiveState(bool aIsActive);

  void SetFrame(nsPluginFrame *aFrame);

  nsPluginFrame* GetFrame();

  uint32_t GetLastEventloopNestingLevel() const {

    return mLastEventloopNestingLevel;

  }

  static uint32_t GetEventloopNestingLevel();

  void ConsiderNewEventloopNestingLevel() {

    uint32_t currentLevel = GetEventloopNestingLevel();

    if (currentLevel < mLastEventloopNestingLevel) {

      mLastEventloopNestingLevel = currentLevel;

    }

  }

  const char* GetPluginName()

  {

    if (mInstance && mPluginHost) {

      const char* name = nullptr;

      if (NS_SUCCEEDED(mPluginHost->GetPluginName(mInstance, &name)) && name)

        return name;

    }

    return "";

  }

#ifdef MOZ_X11

  void GetPluginDescription(nsACString& aDescription)

  {

    aDescription.Truncate();

    if (mInstance && mPluginHost) {

      nsCOMPtr<nsIPluginTag> pluginTag;

      mPluginHost->GetPluginTagForInstance(mInstance,

                                           getter_AddRefs(pluginTag));

      if (pluginTag) {

        pluginTag->GetDescription(aDescription);

      }

    }

  }

#endif

  bool SendNativeEvents()

  {

#ifdef XP_WIN

    // XXX we should remove the plugin name check

    return mPluginWindow->type == NPWindowTypeDrawable &&

    (MatchPluginName("Shockwave Flash") ||

     MatchPluginName("Test Plug-in"));

#elif defined(MOZ_X11) || defined(XP_MACOSX)

    return true;

#else

    return false;

#endif

  }

  bool MatchPluginName(const char *aPluginName)

  {

    return strncmp(GetPluginName(), aPluginName, strlen(aPluginName)) == 0;

  }

  void NotifyPaintWaiter(nsDisplayListBuilder* aBuilder);

  // Returns the image container that has our currently displayed image.

  already_AddRefed<mozilla::layers::ImageContainer> GetImageContainer();

  // Returns true if this is windowed plugin that can return static captures

  // for scroll operations.

  bool NeedsScrollImageLayer();

  void DidComposite();

  /**

   * Returns the bounds of the current async-rendered surface. This can only

   * change in response to messages received by the event loop (i.e. not during

   * painting).

   */

  nsIntSize GetCurrentImageSize();

  // Methods to update the background image we send to async plugins.

  // The eventual target of these operations is PluginInstanceParent,

  // but it takes several hops to get there.

  void SetBackgroundUnknown();

  already_AddRefed<DrawTarget> BeginUpdateBackground(const nsIntRect& aRect);

  void EndUpdateBackground(const nsIntRect& aRect);

  bool UseAsyncRendering();

  already_AddRefed<nsIURI> GetBaseURI() const;

  bool GetCompositionString(uint32_t aIndex, nsTArray<uint8_t>* aString,

                            int32_t* aLength);

  bool SetCandidateWindow(

           const mozilla::widget::CandidateWindowPosition& aPosition);

  bool RequestCommitOrCancel(bool aCommitted);

  bool EnableIME(bool aEnable);

  // See nsIKeyEventInPluginCallback

  virtual void HandledWindowedPluginKeyEvent(

                 const mozilla::NativeEventData& aKeyEventData,

                 bool aIsConsumed) override;

  /**

   * OnWindowedPluginKeyEvent() is called when the plugin process receives

   * native key event directly.

   *

   * @param aNativeKeyData      The key event which was received by the

   *                            plugin process directly.

   */

  void OnWindowedPluginKeyEvent(

         const mozilla::NativeEventData& aNativeKeyData);

  void GetCSSZoomFactor(float *result);

private:

  virtual ~nsPluginInstanceOwner();

  // return FALSE if LayerSurface dirty (newly created and don't have valid plugin content yet)

  bool IsUpToDate()

  {

    nsIntSize size;

    return NS_SUCCEEDED(mInstance->GetImageSize(&size)) &&

    size == nsIntSize(mPluginWindow->width, mPluginWindow->height);

  }

#if defined(XP_WIN)

  nsIWidget* GetContainingWidgetIfOffset();

  already_AddRefed<mozilla::TextComposition> GetTextComposition();

  void HandleNoConsumedCompositionMessage(

    mozilla::WidgetCompositionEvent* aCompositionEvent,

    const NPEvent* aPluginEvent);

  bool mGotCompositionData;

  bool mSentStartComposition;

  bool mPluginDidNotHandleIMEComposition;

#endif

  nsPluginNativeWindow       *mPluginWindow;

  RefPtr<nsNPAPIPluginInstance> mInstance;

  nsPluginFrame              *mPluginFrame;

  nsWeakPtr                   mContent; // WEAK, content owns us

  nsCString                   mDocumentBase;

  bool                        mWidgetCreationComplete;

  nsCOMPtr<nsIWidget>         mWidget;

  RefPtr<nsPluginHost>      mPluginHost;

#ifdef XP_MACOSX

  static mozilla::StaticRefPtr<nsITimer>    sCATimer;

  static nsTArray<nsPluginInstanceOwner*>  *sCARefreshListeners;

  bool                                      mSentInitialTopLevelWindowEvent;

  bool                                      mLastWindowIsActive;

  bool                                      mLastContentFocused;

  // True if, the next time the window is activated, we should blur ourselves.

  bool                                      mShouldBlurOnActivate;

#endif

  double                                    mLastScaleFactor;

  double                                    mLastCSSZoomFactor;

  // Initially, the event loop nesting level we were created on, it's updated

  // if we detect the appshell is on a lower level as long as we're not stopped.

  // We delay DoStopPlugin() until the appshell reaches this level or lower.

  uint32_t                    mLastEventloopNestingLevel;

  bool                        mContentFocused;

  bool                        mWidgetVisible;    // used on Mac to store our widget's visible state

#ifdef MOZ_X11

  // Used with windowless plugins only, initialized in CreateWidget().

  bool                        mFlash10Quirks;

#endif

  bool                        mPluginWindowVisible;

  bool                        mPluginDocumentActiveState;

#ifdef XP_MACOSX

  NPEventModel mEventModel;

  // This is a hack! UseAsyncRendering() can incorrectly return false

  // when we don't have an object frame (possible as of bug 90268).

  // We hack around this by always returning true if we've ever

  // returned true.

  bool mUseAsyncRendering;

#endif

  // pointer to wrapper for nsIDOMContextMenuListener

  RefPtr<nsPluginDOMContextMenuListener> mCXMenuListener;

  nsresult DispatchKeyToPlugin(mozilla::dom::Event* aKeyEvent);

  nsresult DispatchMouseToPlugin(mozilla::dom::Event* aMouseEvent,

                                 bool aAllowPropagate = false);

  nsresult DispatchFocusToPlugin(mozilla::dom::Event* aFocusEvent);

  nsresult DispatchCompositionToPlugin(mozilla::dom::Event* aEvent);

#ifdef XP_WIN

  void CallDefaultProc(const mozilla::WidgetGUIEvent* aEvent);

#endif

#ifdef XP_MACOSX

  static NPBool ConvertPointPuppet(PuppetWidget *widget, nsPluginFrame* pluginFrame,

                            double sourceX, double sourceY, NPCoordinateSpace sourceSpace,

                            double *destX, double *destY, NPCoordinateSpace destSpace);

  static NPBool ConvertPointNoPuppet(nsIWidget *widget, nsPluginFrame* pluginFrame,

                            double sourceX, double sourceY, NPCoordinateSpace sourceSpace,

                            double *destX, double *destY, NPCoordinateSpace destSpace);

  void PerformDelayedBlurs();

#endif    // XP_MACOSX

  int mLastMouseDownButtonType;

#ifdef MOZ_X11

  class Renderer : public gfxXlibNativeRenderer

  {

  public:

    Renderer(NPWindow* aWindow, nsPluginInstanceOwner* aInstanceOwner,

             const nsIntSize& aPluginSize, const nsIntRect& aDirtyRect)

    : mWindow(aWindow), mInstanceOwner(aInstanceOwner),

    mPluginSize(aPluginSize), mDirtyRect(aDirtyRect)

    {}

    virtual nsresult DrawWithXlib(cairo_surface_t* surface,

                                  nsIntPoint offset,

                                  nsIntRect* clipRects, uint32_t numClipRects) override;

  private:

    NPWindow* mWindow;

    nsPluginInstanceOwner* mInstanceOwner;

    const nsIntSize& mPluginSize;

    const nsIntRect& mDirtyRect;

  };

#endif

  bool mWaitingForPaint;

};

#endif // nsPluginInstanceOwner_h_