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

/*

 * A base class implementing nsIObjectLoadingContent for use by

 * various content nodes that want to provide plugin/document/image

 * loading functionality (eg <embed>, <object>, etc).

 */

#ifndef NSOBJECTLOADINGCONTENT_H_

#define NSOBJECTLOADINGCONTENT_H_

#include "mozilla/Attributes.h"

#include "mozilla/dom/BindingDeclarations.h"

#include "nsImageLoadingContent.h"

#include "nsIStreamListener.h"

#include "nsIChannelEventSink.h"

#include "nsIContentPolicy.h"

#include "nsIObjectLoadingContent.h"

#include "nsIRunnable.h"

#include "nsIThreadInternal.h"

#include "nsIFrame.h"

#include "nsIFrameLoaderOwner.h"

class nsAsyncInstantiateEvent;

class nsStopPluginRunnable;

class AutoSetInstantiatingToFalse;

class nsIPrincipal;

class nsFrameLoader;

class nsPluginFrame;

class nsPluginInstanceOwner;

namespace mozilla {

namespace dom {

template<typename T> class Sequence;

struct MozPluginParameter;

class HTMLIFrameElement;

class XULFrameElement;

} // namespace dom

} // namespace mozilla

class nsObjectLoadingContent : public nsImageLoadingContent

                             , public nsIStreamListener

                             , public nsIFrameLoaderOwner

                             , public nsIObjectLoadingContent

                             , public nsIChannelEventSink

{

  friend class AutoSetInstantiatingToFalse;

  friend class AutoSetLoadingToFalse;

  friend class CheckPluginStopEvent;

  friend class nsStopPluginRunnable;

  friend class nsAsyncInstantiateEvent;

  public:

    // This enum's values must be the same as the constants on

    // nsIObjectLoadingContent

    enum ObjectType {

      // Loading, type not yet known. We may be waiting for a channel to open.

      eType_Loading        = TYPE_LOADING,

      // Content is a *non-svg* image

      eType_Image          = TYPE_IMAGE,

      // Content is a plugin

      eType_Plugin         = TYPE_PLUGIN,

      // Content is a fake plugin, which loads as a document but behaves as a

      // plugin (see nsPluginHost::CreateFakePlugin)

      eType_FakePlugin     = TYPE_FAKE_PLUGIN,

      // Content is a subdocument, possibly SVG

      eType_Document       = TYPE_DOCUMENT,

      // No content loaded (fallback). May be showing alternate content or

      // a custom error handler - *including* click-to-play dialogs

      eType_Null           = TYPE_NULL

    };

    enum FallbackType {

      // The content type is not supported (e.g. plugin not installed)

      eFallbackUnsupported = nsIObjectLoadingContent::PLUGIN_UNSUPPORTED,

      // Showing alternate content

      eFallbackAlternate = nsIObjectLoadingContent::PLUGIN_ALTERNATE,

      // The plugin exists, but is disabled

      eFallbackDisabled = nsIObjectLoadingContent::PLUGIN_DISABLED,

      // The plugin is blocklisted and disabled

      eFallbackBlocklisted = nsIObjectLoadingContent::PLUGIN_BLOCKLISTED,

      // The plugin is considered outdated, but not disabled

      eFallbackOutdated = nsIObjectLoadingContent::PLUGIN_OUTDATED,

      // The plugin has crashed

      eFallbackCrashed = nsIObjectLoadingContent::PLUGIN_CRASHED,

      // Suppressed by security policy

      eFallbackSuppressed = nsIObjectLoadingContent::PLUGIN_SUPPRESSED,

      // Blocked by content policy

      eFallbackUserDisabled = nsIObjectLoadingContent::PLUGIN_USER_DISABLED,

      /// ** All values >= eFallbackClickToPlay are plugin placeholder types

      ///    that would be replaced by a real plugin if activated (PlayPlugin())

      /// ** Furthermore, values >= eFallbackClickToPlay and

      ///    <= eFallbackClickToPlayQuiet are click-to-play types.

      // The plugin is disabled until the user clicks on it

      eFallbackClickToPlay = nsIObjectLoadingContent::PLUGIN_CLICK_TO_PLAY,

      // The plugin is vulnerable (update available)

      eFallbackVulnerableUpdatable = nsIObjectLoadingContent::PLUGIN_VULNERABLE_UPDATABLE,

      // The plugin is vulnerable (no update available)

      eFallbackVulnerableNoUpdate = nsIObjectLoadingContent::PLUGIN_VULNERABLE_NO_UPDATE,

      // The plugin is click-to-play, but the user won't see overlays

      eFallbackClickToPlayQuiet = nsIObjectLoadingContent::PLUGIN_CLICK_TO_PLAY_QUIET,

    };

    nsObjectLoadingContent();

    virtual ~nsObjectLoadingContent();

    NS_DECL_NSIREQUESTOBSERVER

    NS_DECL_NSISTREAMLISTENER

    NS_DECL_NSIFRAMELOADEROWNER

    NS_DECL_NSIOBJECTLOADINGCONTENT

    NS_DECL_NSICHANNELEVENTSINK

    /**

     * Object state. This is a bitmask of NS_EVENT_STATEs epresenting the

     * current state of the object.

     */

    mozilla::EventStates ObjectState() const;

    ObjectType Type() const { return mType; }

    void SetIsNetworkCreated(bool aNetworkCreated)

    {

      mNetworkCreated = aNetworkCreated;

    }

    /**

     * When the object is loaded, the attributes and all nested <param>

     * elements are cached as name:value string pairs to be passed as

     * parameters when instantiating the plugin.

     *

     * Note: these cached values can be overriden for different quirk cases.

     */

    // Returns the cached attributes array.

    void GetPluginAttributes(nsTArray<mozilla::dom::MozPluginParameter>& aAttributes);

    // Returns the cached <param> array.

    void GetPluginParameters(nsTArray<mozilla::dom::MozPluginParameter>& aParameters);

    /**

     * Immediately instantiate a plugin instance. This is a no-op if mType !=

     * eType_Plugin or a plugin is already running.

     *

     * aIsLoading indicates that we are in the loading code, and we can bypass

     * the mIsLoading check.

     */

    nsresult InstantiatePluginInstance(bool aIsLoading = false);

    /**

     * Notify this class the document state has changed

     * Called by nsDocument so we may suspend plugins in inactive documents)

     */

    void NotifyOwnerDocumentActivityChanged();

    /**

     * When a plug-in is instantiated, it can create a scriptable

     * object that the page wants to interact with.  We expose this

     * object by placing it on the prototype chain of our element,

     * between the element itself and its most-derived DOM prototype.

     *

     * SetupProtoChain handles actually inserting the plug-in

     * scriptable object into the proto chain if needed.

     *

     * DoResolve is a hook that allows us to find out when the web

     * page is looking up a property name on our object and make sure

     * that our plug-in, if any, is instantiated.

     */

    // Helper for WebIDL node wrapping

    void SetupProtoChain(JSContext* aCx, JS::Handle<JSObject*> aObject);

    // Remove plugin from protochain

    void TeardownProtoChain();

    // Helper for WebIDL NeedResolve

    bool DoResolve(JSContext* aCx, JS::Handle<JSObject*> aObject,

                   JS::Handle<jsid> aId,

                   JS::MutableHandle<JS::PropertyDescriptor> aDesc);

    // The return value is whether DoResolve might end up resolving the given

    // id.  If in doubt, return true.

    static bool MayResolve(jsid aId);

    // Helper for WebIDL enumeration

    void GetOwnPropertyNames(JSContext* aCx, JS::AutoIdVector& /* unused */,

                             bool /* unused */, mozilla::ErrorResult& aRv);

    // WebIDL API

    nsIDocument* GetContentDocument(nsIPrincipal& aSubjectPrincipal);

    void GetActualType(nsAString& aType) const

    {

      CopyUTF8toUTF16(mContentType, aType);

    }

    uint32_t DisplayedType() const

    {

      return mType;

    }

    uint32_t GetContentTypeForMIMEType(const nsAString& aMIMEType)

    {

      return GetTypeOfContent(NS_ConvertUTF16toUTF8(aMIMEType), false);

    }

    void PlayPlugin(mozilla::dom::SystemCallerGuarantee,

                    mozilla::ErrorResult& aRv);

    void Reload(bool aClearActivation, mozilla::ErrorResult& aRv)

    {

      aRv = Reload(aClearActivation);

    }

    bool Activated() const

    {

      return mActivated;

    }

    nsIURI* GetSrcURI() const

    {

      return mURI;

    }

    /**

     * The default state that this plugin would be without manual activation.

     * @returns PLUGIN_ACTIVE if the default state would be active.

     */

    uint32_t DefaultFallbackType();

    uint32_t PluginFallbackType() const

    {

      return mFallbackType;

    }

    bool HasRunningPlugin() const

    {

      return !!mInstanceOwner;

    }

    // FIXME rename this

    void SkipFakePlugins(mozilla::ErrorResult& aRv)

    {

      aRv = SkipFakePlugins();

    }

    void SwapFrameLoaders(mozilla::dom::HTMLIFrameElement& aOtherLoaderOwner,

                          mozilla::ErrorResult& aRv)

    {

      aRv.Throw(NS_ERROR_NOT_IMPLEMENTED);

    }

    void SwapFrameLoaders(mozilla::dom::XULFrameElement& aOtherLoaderOwner,

                          mozilla::ErrorResult& aRv)

    {

      aRv.Throw(NS_ERROR_NOT_IMPLEMENTED);

    }

    void LegacyCall(JSContext* aCx, JS::Handle<JS::Value> aThisVal,

                    const mozilla::dom::Sequence<JS::Value>& aArguments,

                    JS::MutableHandle<JS::Value> aRetval,

                    mozilla::ErrorResult& aRv);

    uint32_t GetRunID(mozilla::dom::SystemCallerGuarantee,

                      mozilla::ErrorResult& aRv);

    bool IsRewrittenYoutubeEmbed() const

    {

      return mRewrittenYoutubeEmbed;

    }

    void PresetOpenerWindow(mozIDOMWindowProxy* aOpenerWindow, mozilla::ErrorResult& aRv);

  protected:

    /**

     * Begins loading the object when called

     *

     * Attributes of |this| QI'd to nsIContent will be inspected, depending on

     * the node type. This function currently assumes it is a <object> or

     * <embed> tag.

     *

     * The instantiated plugin depends on:

     * - The URI (<embed src>, <object data>)

     * - The type 'hint' (type attribute)

     * - The mime type returned by opening the URI

     * - Enabled plugins claiming the ultimate mime type

     * - The capabilities returned by GetCapabilities

     * - The classid attribute, if eFallbackIfClassIDPresent is among the capabilities

     *

     * If eAllowPluginSkipChannel is true, we may skip opening the URI if our

     * type hint points to a valid plugin, deferring that responsibility to the

     * plugin.

     * Similarly, if no URI is provided, but a type hint for a valid plugin is

     * present, that plugin will be instantiated

     *

     * Otherwise a request to that URI is made and the type sent by the server

     * is used to find a suitable handler, EXCEPT when:

     *  - The type hint refers to a *supported* plugin, in which case that

     *    plugin will be instantiated regardless of the server provided type

     *  - The server returns a binary-stream type, and our type hint refers to

     *    a valid non-document type, we will use the type hint

     *

     * @param aNotify    If we should send notifications. If false, content

     *                   loading may be deferred while appropriate frames are

     *                   created

     * @param aForceLoad If we should reload this content (and re-attempt the

     *                   channel open) even if our parameters did not change

     */

    nsresult LoadObject(bool aNotify,

                        bool aForceLoad = false);

    enum Capabilities {

      eSupportImages       = 1u << 0, // Images are supported (imgILoader)

      eSupportPlugins      = 1u << 1, // Plugins are supported (nsIPluginHost)

      eSupportDocuments    = 1u << 2, // Documents are supported

                                      // (nsIDocumentLoaderFactory)

                                      // This flag always includes SVG

      // Node supports class ID as an attribute, and should fallback if it is

      // present, as class IDs are not supported.

      eFallbackIfClassIDPresent = 1u << 3,

      // If possible to get a *plugin* type from the type attribute *or* file

      // extension, we can use that type and begin loading the plugin before

      // opening a channel.

      // A side effect of this is if the channel fails, the plugin is still

      // running.

      eAllowPluginSkipChannel  = 1u << 4

    };

    /**

     * Returns the list of capabilities this content node supports. This is a

     * bitmask consisting of flags from the Capabilities enum.

     *

     * The default implementation supports all types but not

     * eSupportClassID or eAllowPluginSkipChannel

     */

    virtual uint32_t GetCapabilities() const;

    /**

     * Destroys all loaded documents/plugins and releases references

     */

    void DestroyContent();

    static void Traverse(nsObjectLoadingContent *tmp,

                         nsCycleCollectionTraversalCallback &cb);

    void CreateStaticClone(nsObjectLoadingContent* aDest) const;

    void DoStopPlugin(nsPluginInstanceOwner* aInstanceOwner);

    nsresult BindToTree(nsIDocument* aDocument,

                        nsIContent* aParent,

                        nsIContent* aBindingParent);

    void UnbindFromTree(bool aDeep = true,

                        bool aNullParent = true);

    /**

     * Return the content policy type used for loading the element.

     */

    virtual nsContentPolicyType GetContentPolicyType() const = 0;

    /**

     * Decides whether we should load <embed>/<object> node content.

     *

     * If this is an <embed> or <object> node there are cases in which we should

     * not try to load the content:

     *

     * - If the node is the child of a media element

     * - If the node is the child of an <object> node that already has

     *   content being loaded.

     *

     * In these cases, this function will return false, which will cause

     * us to skip calling LoadObject.

     */

    bool BlockEmbedOrObjectContentLoading();

  private:

    // Object parameter changes returned by UpdateObjectParameters

    enum ParameterUpdateFlags {

      eParamNoChange           = 0,

      // Parameters that potentially affect the channel changed

      // - mOriginalURI, mOriginalContentType

      eParamChannelChanged     = 1u << 0,

      // Parameters that affect displayed content changed

      // - mURI, mContentType, mType, mBaseURI

      eParamStateChanged       = 1u << 1,

      // The effective content type changed, independant of object type. This

      // can happen when changing from Loading -> Final type, but doesn't

      // necessarily happen when changing between object types. E.g., if a PDF

      // handler was installed between the last load of this object and now, we

      // might change from eType_Document -> eType_Plugin without changing

      // ContentType

      eParamContentTypeChanged = 1u << 2

    };

    /**

     * Getter for child <param> elements that are not nested in another plugin

     * dom element.

     * This is an internal helper function and should not be used directly for

     * passing parameters to the plugin instance.

     *

     * See GetPluginParameters and GetPluginAttributes, which also handle

     * quirk-overrides.

     *

     * @param aParameters     The array containing pairs of name/value strings

     *                        from nested <param> objects.

     */

    void GetNestedParams(nsTArray<mozilla::dom::MozPluginParameter>& aParameters);

    MOZ_MUST_USE nsresult BuildParametersArray();

    /**

     * Loads fallback content with the specified FallbackType

     *

     * @param aType   FallbackType value for type of fallback we're loading

     * @param aNotify Send notifications and events. If false, caller is

     *                responsible for doing so

     */

    void LoadFallback(FallbackType aType, bool aNotify);

    /**

     * Internal version of LoadObject that should only be used by this class

     * aLoadingChannel is passed by the LoadObject call from OnStartRequest,

     * primarily for sanity-preservation

     */

    nsresult LoadObject(bool aNotify,

                        bool aForceLoad,

                        nsIRequest *aLoadingChannel);

    /**

     * Introspects the object and sets the following member variables:

     * - mOriginalContentType : This is the type attribute on the element

     * - mOriginalURI         : The src or data attribute on the element

     * - mURI                 : The final URI, considering mChannel if

     *                          mChannelLoaded is set

     * - mContentType         : The final content type, considering mChannel if

     *                          mChannelLoaded is set

     * - mBaseURI             : The object's base URI, which may be set by the

     *                          object

     * - mType                : The type the object is determined to be based

     *                          on the above

     *

     * NOTE The class assumes that mType is the currently loaded type at various

     *      points, so the caller of this function must take the appropriate

     *      actions to ensure this

     *

     * NOTE This function does not perform security checks, only determining the

     *      requested type and parameters of the object.

     *

     * @return Returns a bitmask of ParameterUpdateFlags values

     */

    ParameterUpdateFlags UpdateObjectParameters();

    /**

     * Queue a CheckPluginStopEvent and track it in mPendingCheckPluginStopEvent

     */

    void QueueCheckPluginStopEvent();

    void NotifyContentObjectWrapper();

    /**

     * Opens the channel pointed to by mURI into mChannel.

     */

    nsresult OpenChannel();

    /**

     * Closes and releases references to mChannel and, if opened, mFinalListener

     */

    nsresult CloseChannel();

    /**

     * If this object should be tested against blocking list.

     */

    bool ShouldBlockContent();

    /**

     * If this object is allowed to play plugin content, or if it would display

     * click-to-play instead.

     * NOTE that this does not actually check if the object is a loadable plugin

     * NOTE This ignores the current activated state. The caller should check

     *      this if appropriate.

     */

    bool ShouldPlay(FallbackType &aReason);

    /**

     * This method tells if the fallback content should be attempted to be used

     * over the original object content.

     * It will look at prefs and this plugin's CTP state to make a decision.

     *

     * NOTE that this doesn't say whether the fallback _will_ be used, only whether

     * we should look into it to possibly use it. The final answer will be

     * given by the PreferFallback method.

     *

     * @param aIsPluginClickToPlay Whether this object instance is CTP.

     */

    bool FavorFallbackMode(bool aIsPluginClickToPlay);

    /**

     * Whether the page has provided good fallback content to this object.

     */

    bool HasGoodFallback();

    /**

     * This method tells the final answer on whether this object's fallback

     * content should be used instead of the original plugin content.

     *

     * @param aIsPluginClickToPlay Whether this object instance is CTP.

     */

    bool PreferFallback(bool aIsPluginClickToPlay);

    /**

     * Helper to check if our current URI passes policy

     *

     * @param aContentPolicy [out] The result of the content policy decision

     *

     * @return true if call succeeded and NS_CP_ACCEPTED(*aContentPolicy)

     */

    bool CheckLoadPolicy(int16_t *aContentPolicy);

    /**

     * Helper to check if the object passes process policy. Assumes we have a

     * final determined type.

     *

     * @param aContentPolicy [out] The result of the content policy decision

     *

     * @return true if call succeeded and NS_CP_ACCEPTED(*aContentPolicy)

     */

    bool CheckProcessPolicy(int16_t *aContentPolicy);

    /**

     * Gets the plugin instance and creates a plugin stream listener, assigning

     * it to mFinalListener

     */

    bool MakePluginListener();

    void SetupFrameLoader(int32_t aJSPluginId);

    /**

     * Helper to spawn mFrameLoader and return a pointer to its docshell

     *

     * @param aURI URI we intend to load for the recursive load check (does not

     *             actually load anything)

     */

    already_AddRefed<nsIDocShell> SetupDocShell(nsIURI* aRecursionCheckURI);

    /**

     * Unloads all content and resets the object to a completely unloaded state

     *

     * NOTE Calls StopPluginInstance() and may spin the event loop

     *

     * @param aResetState Reset the object type to 'loading' and destroy channel

     *                    as well

     */

    void UnloadObject(bool aResetState = true);

    /**

     * Notifies document observes about a new type/state of this object.

     * Triggers frame construction as needed. mType must be set correctly when

     * this method is called. This method is cheap if the type and state didn't

     * actually change.

     *

     * @param aSync If a synchronous frame construction is required. If false,

     *              the construction may either be sync or async.

     * @param aNotify if false, only need to update the state of our element.

     */

    void NotifyStateChanged(ObjectType aOldType,

                            mozilla::EventStates aOldState,

                            bool aSync, bool aNotify);

    /**

     * Returns a ObjectType value corresponding to the type of content we would

     * support the given MIME type as, taking capabilities and plugin state

     * into account

     *

     * @param aNoFakePlugin Don't select a fake plugin handler as a valid type,

     *                      as when SkipFakePlugins() is called.

     * @return The ObjectType enum value that we would attempt to load

     *

     * NOTE this does not consider whether the content would be suppressed by

     *      click-to-play or other content policy checks

     */

    ObjectType GetTypeOfContent(const nsCString& aMIMEType, bool aNoFakePlugin);

    /**

     * Gets the frame that's associated with this content node.

     * Does not flush.

     */

    nsPluginFrame* GetExistingFrame();

    /**

     * Used for identifying whether we can rewrite a youtube flash embed to

     * possibly use HTML5 instead.

     *

     * Returns true if plugin.rewrite_youtube_embeds pref is true and the

     * element this nsObjectLoadingContent instance represents:

     *

     * - is an embed or object node

     * - has a URL pointing at the youtube.com domain, using "/v/" style video

     *   path reference.

     *

     * Having the enablejsapi flag means the document that contains the element

     * could possibly be manipulating the youtube video elsewhere on the page

     * via javascript. In the context of embed elements, this usage has been

     * deprecated by youtube, so we can just rewrite as normal.

     *

     * If we can rewrite the URL, we change the "/v/" to "/embed/", and change

     * our type to eType_Document so that we render similarly to an iframe

     * embed.

     */

    void MaybeRewriteYoutubeEmbed(nsIURI* aURI,

                                  nsIURI* aBaseURI,

                                  nsIURI** aRewrittenURI);

    // Helper class for SetupProtoChain

    class SetupProtoChainRunner final : public nsIRunnable

    {

      ~SetupProtoChainRunner() = default;

    public:

      NS_DECL_ISUPPORTS

      explicit SetupProtoChainRunner(nsObjectLoadingContent* aContent);

      NS_IMETHOD Run() override;

    private:

      // We store an nsIObjectLoadingContent because we can

      // unambiguously refcount that.

      RefPtr<nsIObjectLoadingContent> mContent;

    };

    // Utility getter for getting our nsNPAPIPluginInstance in a safe way.

    nsresult ScriptRequestPluginInstance(JSContext* aCx,

                                         nsNPAPIPluginInstance** aResult);

    // Utility method for getting our plugin JSObject

    static nsresult GetPluginJSObject(JSContext *cx,

                                      nsNPAPIPluginInstance *plugin_inst,

                                      JS::MutableHandle<JSObject*> plugin_obj,

                                      JS::MutableHandle<JSObject*> plugin_proto);

    // Utility for firing an error event, if we're an <object>.

    void MaybeFireErrorEvent();

    // The final listener for mChannel (uriloader, pluginstreamlistener, etc.)

    nsCOMPtr<nsIStreamListener> mFinalListener;

    // Frame loader, for content documents we load.

    RefPtr<nsFrameLoader>     mFrameLoader;

    // Track if we have a pending AsyncInstantiateEvent

    nsCOMPtr<nsIRunnable>       mPendingInstantiateEvent;

    // Tracks if we have a pending CheckPluginStopEvent

    nsCOMPtr<nsIRunnable>       mPendingCheckPluginStopEvent;

    // The content type of our current load target, updated by

    // UpdateObjectParameters(). Takes the channel's type into account once

    // opened.

    //

    // May change if a channel is opened, does not imply a loaded state

    nsCString                   mContentType;

    // The content type 'hint' provided by the element's type attribute. May

    // or may not be used as a final type

    nsCString                   mOriginalContentType;

    // The channel that's currently being loaded. If set, but mChannelLoaded is

    // false, has not yet reached OnStartRequest

    nsCOMPtr<nsIChannel>        mChannel;

    // The URI of the current content.

    // May change as we open channels and encounter redirects - does not imply

    // a loaded type

    nsCOMPtr<nsIURI>            mURI;

    // The original URI obtained from inspecting the element. May differ from

    // mURI due to redirects

    nsCOMPtr<nsIURI>            mOriginalURI;

    // The baseURI used for constructing mURI.

    nsCOMPtr<nsIURI>            mBaseURI;

    // Type of the currently-loaded content.

    ObjectType                  mType           : 8;

    // The type of fallback content we're showing (see ObjectState())

    FallbackType                mFallbackType : 8;

    uint32_t                    mRunID;

    bool                        mHasRunID : 1;

    // If true, we have opened a channel as the listener and it has reached

    // OnStartRequest. Does not get set for channels that are passed directly to

    // the plugin listener.

    bool                        mChannelLoaded    : 1;

    // Whether we are about to call instantiate on our frame. If we aren't,

    // SetFrame needs to asynchronously call Instantiate.

    bool                        mInstantiating : 1;

    // True when the object is created for an element which the parser has

    // created using NS_FROM_PARSER_NETWORK flag. If the element is modified,

    // it may lose the flag.

    bool                        mNetworkCreated : 1;

    // Used to keep track of whether or not a plugin has been explicitly

    // activated by PlayPlugin(). (see ShouldPlay())

    bool                        mActivated : 1;

    // Whether content blocking is enabled or not for this object.

    bool                        mContentBlockingEnabled : 1;

    // If we should not use fake plugins until the next type change

    bool                        mSkipFakePlugins : 1;

    // Protects DoStopPlugin from reentry (bug 724781).

    bool                        mIsStopping : 1;

    // Protects LoadObject from re-entry

    bool                        mIsLoading : 1;

    // For plugin stand-in types (click-to-play) tracks whether content js has

    // tried to access the plugin script object.

    bool                        mScriptRequested : 1;

    // True if object represents an object/embed tag pointing to a flash embed

    // for a youtube video. When possible (see IsRewritableYoutubeEmbed function

    // comments for details), we change these to try to load HTML5 versions of

    // videos.

    bool                        mRewrittenYoutubeEmbed : 1;

    // Cache the answer of PreferFallback() because ShouldPlay is called several

    // times during the load process.

    bool                        mPreferFallback : 1;

    bool                        mPreferFallbackKnown : 1;

    WeakFrame                   mPrintFrame;

    RefPtr<nsPluginInstanceOwner> mInstanceOwner;

    nsTArray<mozilla::dom::MozPluginParameter> mCachedAttributes;

    nsTArray<mozilla::dom::MozPluginParameter> mCachedParameters;

};

#endif