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

#ifndef mozilla_tabs_TabParent_h
#define mozilla_tabs_TabParent_h

#include "js/TypeDecls.h"
#include "mozilla/ContentCache.h"
#include "mozilla/dom/AudioChannelBinding.h"
#include "mozilla/dom/ipc/IdType.h"
#include "mozilla/dom/PBrowserParent.h"
#include "mozilla/dom/PContent.h"
#include "mozilla/dom/PFilePickerParent.h"
#include "mozilla/dom/TabContext.h"
#include "mozilla/EventForwards.h"
#include "mozilla/dom/File.h"
#include "mozilla/layers/CompositorBridgeParent.h"
#include "mozilla/RefPtr.h"
#include "mozilla/Move.h"
#include "nsCOMPtr.h"
#include "nsIAuthPromptProvider.h"
#include "nsIBrowserDOMWindow.h"
#include "nsIDOMEventListener.h"
#include "nsIKeyEventInPluginCallback.h"
#include "nsISecureBrowserUI.h"
#include "nsITabParent.h"
#include "nsIWebBrowserPersistable.h"
#include "nsIXULBrowserWindow.h"
#include "nsRefreshDriver.h"
#include "nsWeakReference.h"
#include "Units.h"
#include "nsIWidget.h"

class nsFrameLoader;
class nsIFrameLoader;
class nsIContent;
class nsIPrincipal;
class nsIURI;
class nsILoadContext;
class nsIDocShell;

namespace mozilla {

namespace a11y {
class DocAccessibleParent;
}

namespace jsipc {
class CpowHolder;
} // namespace jsipc

namespace layers {
struct TextureFactoryIdentifier;
} // namespace layers

namespace layout {
class RenderFrameParent;
} // namespace layout

namespace widget {
struct IMENotification;
} // namespace widget

namespace gfx {
class SourceSurface;
class DataSourceSurface;
} // namespace gfx

namespace dom {

class ClonedMessageData;
class nsIContentParent;
class Element;
class DataTransfer;

namespace ipc {
class StructuredCloneData;
} // ipc namespace

// This observer runs on the compositor thread, so we dispatch a runnable to the
// main thread to actually dispatch the event.
class LayerTreeUpdateObserver : public layers::CompositorUpdateObserver
{
public:
  explicit LayerTreeUpdateObserver(TabParent* aTabParent)
    : mTabParent(aTabParent)
  {
    MOZ_ASSERT(NS_IsMainThread());
  }

  virtual void ObserveUpdate(uint64_t aLayersId, bool aActive) override;

  virtual void SwapTabParent(LayerTreeUpdateObserver* aOther) {
    MOZ_ASSERT(NS_IsMainThread());
    Swap(mTabParent, aOther->mTabParent);
  }

  void TabParentDestroyed() {
    MOZ_ASSERT(NS_IsMainThread());
    mTabParent = nullptr;
  }

  TabParent* GetTabParent() {
    MOZ_ASSERT(NS_IsMainThread());
    return mTabParent;
  }

private:
  // NB: Should never be touched off the main thread!
  TabParent* mTabParent;
};

class TabParent final : public PBrowserParent
                      , public nsIDOMEventListener
                      , public nsITabParent
                      , public nsIAuthPromptProvider
                      , public nsISecureBrowserUI
                      , public nsIKeyEventInPluginCallback
                      , public nsSupportsWeakReference
                      , public TabContext
                      , public nsAPostRefreshObserver
                      , public nsIWebBrowserPersistable
{
  typedef mozilla::dom::ClonedMessageData ClonedMessageData;

  virtual ~TabParent();

public:
  // Helper class for ContentParent::RecvCreateWindow.
  struct AutoUseNewTab;

  // nsITabParent
  NS_DECL_NSITABPARENT
  // nsIDOMEventListener interfaces
  NS_DECL_NSIDOMEVENTLISTENER

  TabParent(nsIContentParent* aManager,
            const TabId& aTabId,
            const TabContext& aContext,
            uint32_t aChromeFlags);

  Element* GetOwnerElement() const { return mFrameElement; }
  already_AddRefed<nsPIDOMWindowOuter> GetParentWindowOuter();

  void SetOwnerElement(Element* aElement);

  void CacheFrameLoader(nsFrameLoader* aFrameLoader);

  /**
   * Get the mozapptype attribute from this TabParent's owner DOM element.
   */
  void GetAppType(nsAString& aOut);

  /**
   * Returns true iff this TabParent's nsIFrameLoader is visible.
   *
   * The frameloader's visibility can be independent of e.g. its docshell's
   * visibility.
   */
  bool IsVisible() const;

  nsIBrowserDOMWindow *GetBrowserDOMWindow() const { return mBrowserDOMWindow; }

  void SetBrowserDOMWindow(nsIBrowserDOMWindow* aBrowserDOMWindow)
  {
    mBrowserDOMWindow = aBrowserDOMWindow;
  }

  void SetHasContentOpener(bool aHasContentOpener);

  void SwapFrameScriptsFrom(nsTArray<FrameScriptInfo>& aFrameScripts)
  {
    aFrameScripts.SwapElements(mDelayedFrameScripts);
  }

  already_AddRefed<nsILoadContext> GetLoadContext();

  already_AddRefed<nsIWidget> GetTopLevelWidget();

  nsIXULBrowserWindow* GetXULBrowserWindow();

  void Destroy();

  void Detach();

  void Attach(nsFrameLoader* aFrameLoader);

  void RemoveWindowListeners();

  void AddWindowListeners();

  void DidRefresh() override;

  virtual bool RecvMoveFocus(const bool& aForward,
                             const bool& aForDocumentNavigation) override;

  virtual bool RecvSizeShellTo(const uint32_t& aFlags,
                               const int32_t& aWidth,
                               const int32_t& aHeight,
                               const int32_t& aShellItemWidth,
                               const int32_t& aShellItemHeight) override;

  virtual bool RecvEvent(const RemoteDOMEvent& aEvent) override;

  virtual bool RecvReplyKeyEvent(const WidgetKeyboardEvent& aEvent) override;

  virtual bool
  RecvDispatchAfterKeyboardEvent(const WidgetKeyboardEvent& aEvent) override;

  virtual bool
  RecvAccessKeyNotHandled(const WidgetKeyboardEvent& aEvent) override;

  virtual bool RecvBrowserFrameOpenWindow(PBrowserParent* aOpener,
                                          PRenderFrameParent* aRenderFrame,
                                          const nsString& aURL,
                                          const nsString& aName,
                                          const nsString& aFeatures,
                                          bool* aOutWindowOpened,
                                          TextureFactoryIdentifier* aTextureFactoryIdentifier,
                                          uint64_t* aLayersId) override;

  virtual bool
  RecvSyncMessage(const nsString& aMessage,
                  const ClonedMessageData& aData,
                  InfallibleTArray<CpowEntry>&& aCpows,
                  const IPC::Principal& aPrincipal,
                  nsTArray<ipc::StructuredCloneData>* aRetVal) override;

  virtual bool
  RecvRpcMessage(const nsString& aMessage,
                 const ClonedMessageData& aData,
                 InfallibleTArray<CpowEntry>&& aCpows,
                 const IPC::Principal& aPrincipal,
                 nsTArray<ipc::StructuredCloneData>* aRetVal) override;

  virtual bool RecvAsyncMessage(const nsString& aMessage,
                                InfallibleTArray<CpowEntry>&& aCpows,
                                const IPC::Principal& aPrincipal,
                                const ClonedMessageData& aData) override;

  virtual bool
  RecvNotifyIMEFocus(const ContentCache& aContentCache,
                     const widget::IMENotification& aEventMessage,
                     nsIMEUpdatePreference* aPreference) override;

  virtual bool
  RecvNotifyIMETextChange(const ContentCache& aContentCache,
                          const widget::IMENotification& aEventMessage) override;

  virtual bool
  RecvNotifyIMECompositionUpdate(const ContentCache& aContentCache,
                                 const widget::IMENotification& aEventMessage) override;

  virtual bool
  RecvNotifyIMESelection(const ContentCache& aContentCache,
                         const widget::IMENotification& aEventMessage) override;

  virtual bool
  RecvUpdateContentCache(const ContentCache& aContentCache) override;

  virtual bool
  RecvNotifyIMEMouseButtonEvent(const widget::IMENotification& aEventMessage,
                                bool* aConsumedByIME) override;

  virtual bool
  RecvNotifyIMEPositionChange(const ContentCache& aContentCache,
                              const widget::IMENotification& aEventMessage) override;

  virtual bool
  RecvOnEventNeedingAckHandled(const EventMessage& aMessage) override;

  virtual bool
  RecvRequestIMEToCommitComposition(const bool& aCancel,
                                    bool* aIsCommitted,
                                    nsString* aCommittedString) override;

  virtual bool
  RecvStartPluginIME(const WidgetKeyboardEvent& aKeyboardEvent,
                     const int32_t& aPanelX,
                     const int32_t& aPanelY,
                     nsString* aCommitted) override;

  virtual bool RecvSetPluginFocused(const bool& aFocused) override;

  virtual bool RecvSetCandidateWindowForPlugin(
                 const widget::CandidateWindowPosition& aPosition) override;

  virtual bool
  RecvDefaultProcOfPluginEvent(const WidgetPluginEvent& aEvent) override;

  virtual bool RecvGetInputContext(int32_t* aIMEEnabled,
                                   int32_t* aIMEOpen) override;

  virtual bool RecvSetInputContext(const int32_t& aIMEEnabled,
                                   const int32_t& aIMEOpen,
                                   const nsString& aType,
                                   const nsString& aInputmode,
                                   const nsString& aActionHint,
                                   const int32_t& aCause,
                                   const int32_t& aFocusChange) override;


  // See nsIKeyEventInPluginCallback
  virtual void HandledWindowedPluginKeyEvent(
                 const NativeEventData& aKeyEventData,
                 bool aIsConsumed) override;

  virtual bool RecvOnWindowedPluginKeyEvent(
                 const NativeEventData& aKeyEventData) override;

  virtual bool RecvRequestFocus(const bool& aCanRaise) override;

  virtual bool RecvLookUpDictionary(
                 const nsString& aText,
                 nsTArray<mozilla::FontRange>&& aFontRangeArray,
                 const bool& aIsVertical,
                 const LayoutDeviceIntPoint& aPoint) override;

  virtual bool
  RecvEnableDisableCommands(const nsString& aAction,
                            nsTArray<nsCString>&& aEnabledCommands,
                            nsTArray<nsCString>&& aDisabledCommands) override;

  virtual bool
  RecvSetCursor(const uint32_t& aValue, const bool& aForce) override;

  virtual bool RecvSetCustomCursor(const nsCString& aUri,
                                   const uint32_t& aWidth,
                                   const uint32_t& aHeight,
                                   const uint32_t& aStride,
                                   const uint8_t& aFormat,
                                   const uint32_t& aHotspotX,
                                   const uint32_t& aHotspotY,
                                   const bool& aForce) override;

  virtual bool RecvSetStatus(const uint32_t& aType,
                             const nsString& aStatus) override;

  virtual bool RecvIsParentWindowMainWidgetVisible(bool* aIsVisible) override;

  virtual bool RecvShowTooltip(const uint32_t& aX,
                               const uint32_t& aY,
                               const nsString& aTooltip,
                               const nsString& aDirection) override;

  virtual bool RecvHideTooltip() override;

  virtual bool RecvGetDPI(float* aValue) override;

  virtual bool RecvGetDefaultScale(double* aValue) override;

  virtual bool RecvGetMaxTouchPoints(uint32_t* aTouchPoints) override;

  virtual bool RecvGetWidgetNativeData(WindowsHandle* aValue) override;

  virtual bool RecvSetNativeChildOfShareableWindow(const uintptr_t& childWindow) override;

  virtual bool RecvDispatchFocusToTopLevelWindow() override;

  virtual bool RecvRespondStartSwipeEvent(const uint64_t& aInputBlockId,
                                          const bool& aStartSwipe) override;

  virtual bool
  RecvDispatchWheelEvent(const mozilla::WidgetWheelEvent& aEvent) override;

  virtual bool
  RecvDispatchMouseEvent(const mozilla::WidgetMouseEvent& aEvent) override;

  virtual bool
  RecvDispatchKeyboardEvent(const mozilla::WidgetKeyboardEvent& aEvent) override;

  virtual PColorPickerParent*
  AllocPColorPickerParent(const nsString& aTitle,
                          const nsString& aInitialColor) override;

  virtual bool
  DeallocPColorPickerParent(PColorPickerParent* aColorPicker) override;

  virtual PDatePickerParent*
  AllocPDatePickerParent(const nsString& aTitle, const nsString& aInitialDate) override;
  virtual bool DeallocPDatePickerParent(PDatePickerParent* aDatePicker) override;

  virtual PDocAccessibleParent*
  AllocPDocAccessibleParent(PDocAccessibleParent*, const uint64_t&) override;

  virtual bool DeallocPDocAccessibleParent(PDocAccessibleParent*) override;

  virtual bool
  RecvPDocAccessibleConstructor(PDocAccessibleParent* aDoc,
                                PDocAccessibleParent* aParentDoc,
                                const uint64_t& aParentID) override;

  /**
   * Return the top level doc accessible parent for this tab.
   */
  a11y::DocAccessibleParent* GetTopLevelDocAccessible() const;

  void LoadURL(nsIURI* aURI);

  // XXX/cjones: it's not clear what we gain by hiding these
  // message-sending functions under a layer of indirection and
  // eating the return values
  void Show(const ScreenIntSize& aSize, bool aParentIsActive);

  void UpdateDimensions(const nsIntRect& aRect, const ScreenIntSize& aSize);

  void SizeModeChanged(const nsSizeMode& aSizeMode);

  void UIResolutionChanged();

  void ThemeChanged();

  void HandleAccessKey(const WidgetKeyboardEvent& aEvent,
                       nsTArray<uint32_t>& aCharCodes,
                       const int32_t& aModifierMask);

  void Activate();

  void Deactivate();

  bool MapEventCoordinatesForChildProcess(mozilla::WidgetEvent* aEvent);

  void MapEventCoordinatesForChildProcess(const LayoutDeviceIntPoint& aOffset,
                                          mozilla::WidgetEvent* aEvent);

  LayoutDeviceToCSSScale GetLayoutDeviceToCSSScale();

  virtual bool
  RecvRequestNativeKeyBindings(const mozilla::WidgetKeyboardEvent& aEvent,
                               MaybeNativeKeyBinding* aBindings) override;

  virtual bool
  RecvSynthesizeNativeKeyEvent(const int32_t& aNativeKeyboardLayout,
                               const int32_t& aNativeKeyCode,
                               const uint32_t& aModifierFlags,
                               const nsString& aCharacters,
                               const nsString& aUnmodifiedCharacters,
                               const uint64_t& aObserverId) override;

  virtual bool
  RecvSynthesizeNativeMouseEvent(const LayoutDeviceIntPoint& aPoint,
                                 const uint32_t& aNativeMessage,
                                 const uint32_t& aModifierFlags,
                                 const uint64_t& aObserverId) override;

  virtual bool
  RecvSynthesizeNativeMouseMove(const LayoutDeviceIntPoint& aPoint,
                                 const uint64_t& aObserverId) override;

  virtual bool
  RecvSynthesizeNativeMouseScrollEvent(const LayoutDeviceIntPoint& aPoint,
                                       const uint32_t& aNativeMessage,
                                       const double& aDeltaX,
                                       const double& aDeltaY,
                                       const double& aDeltaZ,
                                       const uint32_t& aModifierFlags,
                                       const uint32_t& aAdditionalFlags,
                                       const uint64_t& aObserverId) override;

  virtual bool
  RecvSynthesizeNativeTouchPoint(const uint32_t& aPointerId,
                                 const TouchPointerState& aPointerState,
                                 const LayoutDeviceIntPoint& aPoint,
                                 const double& aPointerPressure,
                                 const uint32_t& aPointerOrientation,
                                 const uint64_t& aObserverId) override;

  virtual bool
  RecvSynthesizeNativeTouchTap(const LayoutDeviceIntPoint& aPoint,
                               const bool& aLongTap,
                               const uint64_t& aObserverId) override;

  virtual bool
  RecvClearNativeTouchSequence(const uint64_t& aObserverId) override;

  void SendMouseEvent(const nsAString& aType, float aX, float aY,
                      int32_t aButton, int32_t aClickCount,
                      int32_t aModifiers, bool aIgnoreRootScrollFrame);

  void SendKeyEvent(const nsAString& aType, int32_t aKeyCode,
                    int32_t aCharCode, int32_t aModifiers,
                    bool aPreventDefault);

  bool SendRealMouseEvent(mozilla::WidgetMouseEvent& event);

  bool SendRealDragEvent(mozilla::WidgetDragEvent& aEvent,
                         uint32_t aDragAction,
                         uint32_t aDropEffect);

  bool SendMouseWheelEvent(mozilla::WidgetWheelEvent& event);

  bool SendRealKeyEvent(mozilla::WidgetKeyboardEvent& event);

  bool SendRealTouchEvent(WidgetTouchEvent& event);

  virtual PDocumentRendererParent*
  AllocPDocumentRendererParent(const nsRect& documentRect,
                               const gfx::Matrix& transform,
                               const nsString& bgcolor,
                               const uint32_t& renderFlags,
                               const bool& flushLayout,
                               const nsIntSize& renderSize) override;

  virtual bool
  DeallocPDocumentRendererParent(PDocumentRendererParent* actor) override;

  virtual PFilePickerParent*
  AllocPFilePickerParent(const nsString& aTitle,
                         const int16_t& aMode) override;

  virtual bool DeallocPFilePickerParent(PFilePickerParent* actor) override;

  virtual PIndexedDBPermissionRequestParent*
  AllocPIndexedDBPermissionRequestParent(const Principal& aPrincipal) override;

  virtual bool
  RecvPIndexedDBPermissionRequestConstructor(
                                    PIndexedDBPermissionRequestParent* aActor,
                                    const Principal& aPrincipal)
                                    override;

  virtual bool
  DeallocPIndexedDBPermissionRequestParent(
                                    PIndexedDBPermissionRequestParent* aActor)
                                    override;

  bool GetGlobalJSObject(JSContext* cx, JSObject** globalp);

  NS_DECL_ISUPPORTS
  NS_DECL_NSIAUTHPROMPTPROVIDER
  NS_DECL_NSISECUREBROWSERUI
  NS_DECL_NSIWEBBROWSERPERSISTABLE

  bool HandleQueryContentEvent(mozilla::WidgetQueryContentEvent& aEvent);

  bool SendCompositionEvent(mozilla::WidgetCompositionEvent& event);

  bool SendSelectionEvent(mozilla::WidgetSelectionEvent& event);

  static TabParent* GetFrom(nsFrameLoader* aFrameLoader);

  static TabParent* GetFrom(nsIFrameLoader* aFrameLoader);

  static TabParent* GetFrom(nsITabParent* aTabParent);

  static TabParent* GetFrom(PBrowserParent* aTabParent);

  static TabParent* GetFrom(nsIContent* aContent);

  static TabId GetTabIdFrom(nsIDocShell* docshell);

  nsIContentParent* Manager() const { return mManager; }

  /**
   * Let managees query if Destroy() is already called so they don't send out
   * messages when the PBrowser actor is being destroyed.
   */
  bool IsDestroyed() const { return mIsDestroyed; }

  already_AddRefed<nsIWidget> GetWidget() const;

  const TabId GetTabId() const
  {
    return mTabId;
  }

  LayoutDeviceIntPoint GetChildProcessOffset();
  LayoutDevicePoint AdjustTapToChildWidget(const LayoutDevicePoint& aPoint);

  /**
   * Native widget remoting protocol for use with windowed plugins with e10s.
   */
  virtual PPluginWidgetParent* AllocPPluginWidgetParent() override;

  virtual bool
  DeallocPPluginWidgetParent(PPluginWidgetParent* aActor) override;

  void SetInitedByParent() { mInitedByParent = true; }

  bool IsInitedByParent() const { return mInitedByParent; }

  static TabParent* GetNextTabParent();

  bool SendLoadRemoteScript(const nsString& aURL,
                            const bool& aRunInGlobalScope);

  // See nsIFrameLoader requestNotifyLayerTreeReady.
  bool RequestNotifyLayerTreeReady();

  bool RequestNotifyLayerTreeCleared();

  bool LayerTreeUpdate(bool aActive);

  void SwapLayerTreeObservers(TabParent* aOther);

  virtual bool
  RecvInvokeDragSession(nsTArray<IPCDataTransfer>&& aTransfers,
                        const uint32_t& aAction,
                        const OptionalShmem& aVisualDnDData,
                        const uint32_t& aWidth, const uint32_t& aHeight,
                        const uint32_t& aStride, const uint8_t& aFormat,
                        const int32_t& aDragAreaX, const int32_t& aDragAreaY) override;

  void AddInitialDnDDataTo(DataTransfer* aDataTransfer);

  void TakeDragVisualization(RefPtr<mozilla::gfx::SourceSurface>& aSurface,
                             int32_t& aDragAreaX, int32_t& aDragAreaY);

  layout::RenderFrameParent* GetRenderFrame();

  void AudioChannelChangeNotification(nsPIDOMWindowOuter* aWindow,
                                      AudioChannel aAudioChannel,
                                      float aVolume,
                                      bool aMuted);
  bool SetRenderFrame(PRenderFrameParent* aRFParent);
  bool GetRenderFrameInfo(TextureFactoryIdentifier* aTextureFactoryIdentifier,
                          uint64_t* aLayersId);

protected:
  bool ReceiveMessage(const nsString& aMessage,
                      bool aSync,
                      ipc::StructuredCloneData* aData,
                      mozilla::jsipc::CpowHolder* aCpows,
                      nsIPrincipal* aPrincipal,
                      nsTArray<ipc::StructuredCloneData>* aJSONRetVal = nullptr);

  virtual bool RecvAsyncAuthPrompt(const nsCString& aUri,
                                   const nsString& aRealm,
                                   const uint64_t& aCallbackId) override;

  virtual bool Recv__delete__() override;

  virtual void ActorDestroy(ActorDestroyReason why) override;

  Element* mFrameElement;
  nsCOMPtr<nsIBrowserDOMWindow> mBrowserDOMWindow;

  virtual PRenderFrameParent* AllocPRenderFrameParent() override;

  virtual bool DeallocPRenderFrameParent(PRenderFrameParent* aFrame) override;

  virtual bool RecvRemotePaintIsReady() override;

  virtual bool RecvSetDimensions(const uint32_t& aFlags,
                                 const int32_t& aX, const int32_t& aY,
                                 const int32_t& aCx, const int32_t& aCy) override;

  virtual bool RecvGetTabCount(uint32_t* aValue) override;

  virtual bool RecvAudioChannelActivityNotification(const uint32_t& aAudioChannel,
                                                    const bool& aActive) override;

  ContentCacheInParent mContentCache;

  nsIntRect mRect;
  ScreenIntSize mDimensions;
  ScreenOrientationInternal mOrientation;
  float mDPI;
  CSSToLayoutDeviceScale mDefaultScale;
  bool mUpdatedDimensions;
  nsSizeMode mSizeMode;
  LayoutDeviceIntPoint mClientOffset;
  LayoutDeviceIntPoint mChromeOffset;

private:
  void DestroyInternal();

  already_AddRefed<nsFrameLoader>
  GetFrameLoader(bool aUseCachedFrameLoaderAfterDestroy = false) const;

  RefPtr<nsIContentParent> mManager;
  void TryCacheDPIAndScale();

  nsresult UpdatePosition();

  bool AsyncPanZoomEnabled() const;

  // Cached value indicating the docshell active state of the remote browser.
  bool mDocShellIsActive;

  // Update state prior to routing an APZ-aware event to the child process.
  // |aOutTargetGuid| will contain the identifier
  // of the APZC instance that handled the event. aOutTargetGuid may be null.
  // |aOutInputBlockId| will contain the identifier of the input block
  // that this event was added to, if there was one. aOutInputBlockId may be null.
  // |aOutApzResponse| will contain the response that the APZ gave when processing
  // the input block; this is used for generating appropriate pointercancel events.
  void ApzAwareEventRoutingToChild(ScrollableLayerGuid* aOutTargetGuid,
                                   uint64_t* aOutInputBlockId,
                                   nsEventStatus* aOutApzResponse);

  // When true, we've initiated normal shutdown and notified our managing PContent.
  bool mMarkedDestroying;
  // When true, the TabParent is invalid and we should not send IPC messages anymore.
  bool mIsDestroyed;
  // When true, the TabParent is detached from the frame loader.
  bool mIsDetached;
  // Whether we have already sent a FileDescriptor for the app package.
  bool mAppPackageFileDescriptorSent;

  // Whether we need to send the offline status to the TabChild
  // This is true, until the first call of LoadURL
  bool mSendOfflineStatus;

  uint32_t mChromeFlags;

  nsTArray<nsTArray<IPCDataTransferItem>> mInitialDataTransferItems;

  RefPtr<gfx::DataSourceSurface> mDnDVisualization;
  int32_t mDragAreaX;
  int32_t mDragAreaY;

  // When true, the TabParent is initialized without child side's request.
  // When false, the TabParent is initialized by window.open() from child side.
  bool mInitedByParent;

  nsCOMPtr<nsILoadContext> mLoadContext;

  // We keep a strong reference to the frameloader after we've sent the
  // Destroy message and before we've received __delete__. This allows us to
  // dispatch message manager messages during this time.
  RefPtr<nsFrameLoader> mFrameLoader;

  TabId mTabId;

  // When loading a new tab or window via window.open, the child process sends
  // a new PBrowser to use. We store that tab in sNextTabParent and then
  // proceed through the browser's normal paths to create a new
  // window/tab. When it comes time to create a new TabParent, we instead use
  // sNextTabParent.
  static TabParent* sNextTabParent;

  // When loading a new tab or window via window.open, the child is
  // responsible for loading the URL it wants into the new TabChild. When the
  // parent receives the CreateWindow message, though, it sends a LoadURL
  // message, usually for about:blank. It's important for the about:blank load
  // to get processed because the Firefox frontend expects every new window to
  // immediately start loading something (see bug 1123090). However, we want
  // the child to process the LoadURL message before it returns from
  // ProvideWindow so that the URL sent from the parent doesn't override the
  // child's URL. This is not possible using our IPC mechanisms. To solve the
  // problem, we skip sending the LoadURL message in the parent and instead
  // return the URL as a result from CreateWindow. The child simulates
  // receiving a LoadURL message before returning from ProvideWindow.
  //
  // The mCreatingWindow flag is set while dispatching CreateWindow. During
  // that time, any LoadURL calls are skipped and the URL is stored in
  // mSkippedURL.
  bool mCreatingWindow;
  nsCString mDelayedURL;

  // When loading a new tab or window via window.open, we want to ensure that
  // frame scripts for that tab are loaded before any scripts start to run in
  // the window. We can't load the frame scripts the normal way, using
  // separate IPC messages, since they won't be processed by the child until
  // returning to the event loop, which is too late. Instead, we queue up
  // frame scripts that we intend to load and send them as part of the
  // CreateWindow response. Then TabChild loads them immediately.
  nsTArray<FrameScriptInfo> mDelayedFrameScripts;

  // If the user called RequestNotifyLayerTreeReady and the RenderFrameParent
  // wasn't ready yet, we set this flag and call RequestNotifyLayerTreeReady
  // again once the RenderFrameParent arrives.
  bool mNeedLayerTreeReadyNotification;

  // Cached cursor setting from TabChild.  When the cursor is over the tab,
  // it should take this appearance.
  nsCursor mCursor;
  nsCOMPtr<imgIContainer> mCustomCursor;
  uint32_t mCustomCursorHotspotX, mCustomCursorHotspotY;

  // True if the cursor changes from the TabChild should change the widget
  // cursor.  This happens whenever the cursor is in the tab's region.
  bool mTabSetsCursor;

  RefPtr<nsIPresShell> mPresShellWithRefreshListener;

  bool mHasContentOpener;

#ifdef DEBUG
  int32_t mActiveSupressDisplayportCount;
#endif

  ShowInfo GetShowInfo();

private:
  // This is used when APZ needs to find the TabParent associated with a layer
  // to dispatch events.
  typedef nsDataHashtable<nsUint64HashKey, TabParent*> LayerToTabParentTable;
  static LayerToTabParentTable* sLayerToTabParentTable;

  static void AddTabParentToTable(uint64_t aLayersId, TabParent* aTabParent);

  static void RemoveTabParentFromTable(uint64_t aLayersId);

  RefPtr<LayerTreeUpdateObserver> mLayerUpdateObserver;

public:
  static TabParent* GetTabParentFromLayersId(uint64_t aLayersId);
};

struct MOZ_STACK_CLASS TabParent::AutoUseNewTab final
{
public:
  AutoUseNewTab(TabParent* aNewTab, bool* aWindowIsNew, nsCString* aURLToLoad)
   : mNewTab(aNewTab), mWindowIsNew(aWindowIsNew), mURLToLoad(aURLToLoad)
  {
    MOZ_ASSERT(!TabParent::sNextTabParent);
    MOZ_ASSERT(!aNewTab->mCreatingWindow);

    TabParent::sNextTabParent = aNewTab;
    aNewTab->mCreatingWindow = true;
    aNewTab->mDelayedURL.Truncate();
  }

  ~AutoUseNewTab()
  {
    mNewTab->mCreatingWindow = false;
    *mURLToLoad = mNewTab->mDelayedURL;

    if (TabParent::sNextTabParent) {
      MOZ_ASSERT(TabParent::sNextTabParent == mNewTab);
      TabParent::sNextTabParent = nullptr;
      *mWindowIsNew = false;
    }
  }

private:
  TabParent* mNewTab;
  bool* mWindowIsNew;
  nsCString* mURLToLoad;
};

} // namespace dom
} // namespace mozilla

#endif // mozilla_tabs_TabParent_h
