diff options
Diffstat (limited to '')
| -rw-r--r-- | dom/base/nsObjectLoadingContent.h | 724 |
1 files changed, 724 insertions, 0 deletions
diff --git a/dom/base/nsObjectLoadingContent.h b/dom/base/nsObjectLoadingContent.h new file mode 100644 index 0000000000..95466929a4 --- /dev/null +++ b/dom/base/nsObjectLoadingContent.h @@ -0,0 +1,724 @@ +/* -*- 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/Maybe.h" +#include "mozilla/dom/BindingDeclarations.h" +#include "nsIFrame.h" // for WeakFrame only +#include "nsImageLoadingContent.h" +#include "nsIStreamListener.h" +#include "nsIChannelEventSink.h" +#include "nsIObjectLoadingContent.h" +#include "nsIRunnable.h" +#include "nsFrameLoaderOwner.h" + +class nsAsyncInstantiateEvent; +class nsStopPluginRunnable; +class AutoSetInstantiatingToFalse; +class nsIPrincipal; +class nsFrameLoader; +class nsPluginFrame; +class nsPluginInstanceOwner; + +namespace mozilla { +namespace dom { +struct BindContext; +template <typename T> +class Sequence; +struct MozPluginParameter; +class HTMLIFrameElement; +template <typename T> +struct Nullable; +class WindowProxyHolder; +class XULFrameElement; +} // namespace dom +} // namespace mozilla + +class nsObjectLoadingContent : public nsImageLoadingContent, + public nsIStreamListener, + public nsFrameLoaderOwner, + 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, + /// ** 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, + // Plugins are no longer supported. Content is just a transparent rect. + eFallbackBlockAllPlugins = nsIObjectLoadingContent::PLUGIN_BLOCK_ALL, + }; + + nsObjectLoadingContent(); + virtual ~nsObjectLoadingContent(); + + NS_DECL_NSIREQUESTOBSERVER + NS_DECL_NSISTREAMLISTENER + 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 Document 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::MutableHandleVector<jsid> /* unused */, + bool /* unused */, mozilla::ErrorResult& aRv); + + // WebIDL API + mozilla::dom::Document* 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); + } + + uint32_t GetRunID(mozilla::dom::SystemCallerGuarantee, + mozilla::ErrorResult& aRv); + + bool IsRewrittenYoutubeEmbed() const { return mRewrittenYoutubeEmbed; } + + void PresetOpenerWindow(const mozilla::dom::Nullable< + mozilla::dom::WindowProxyHolder>& aOpenerWindow, + mozilla::ErrorResult& aRv); + + const mozilla::Maybe<mozilla::IntrinsicSize>& GetSubdocumentIntrinsicSize() + const { + return mSubdocumentIntrinsicSize; + } + + const mozilla::Maybe<mozilla::AspectRatio>& GetSubdocumentIntrinsicRatio() + const { + return mSubdocumentIntrinsicRatio; + } + + void SubdocumentIntrinsicSizeOrRatioChanged( + const mozilla::Maybe<mozilla::IntrinsicSize>& aIntrinsicSize, + const mozilla::Maybe<mozilla::AspectRatio>& aIntrinsicRatio); + + 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 + // (DocumentLoaderFactory) + // 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 Destroy(); + + static void Traverse(nsObjectLoadingContent* tmp, + nsCycleCollectionTraversalCallback& cb); + + void CreateStaticClone(nsObjectLoadingContent* aDest) const; + + void DoStopPlugin(nsPluginInstanceOwner* aInstanceOwner); + + nsresult BindToTree(mozilla::dom::BindContext&, nsINode& aParent); + void UnbindFromTree(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, + FallbackType aOldFallbackType, 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. + nsNPAPIPluginInstance* ScriptRequestPluginInstance(JSContext* aCx); + + // 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; + + // 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; + + // The intrinsic size and aspect ratio from a child SVG document that + // we should use. These are only set when we are an <object> or <embed> + // and the inner document is SVG. + // + // We store these here rather than on nsSubDocumentFrame since we are + // sometimes notified of our child's intrinsics before we've constructed + // our own frame. + mozilla::Maybe<mozilla::IntrinsicSize> mSubdocumentIntrinsicSize; + mozilla::Maybe<mozilla::AspectRatio> mSubdocumentIntrinsicRatio; +}; + +#endif |