embed
elementsrc
type
width
height
interface HTMLEmbedElement : HTMLElement { attribute DOMString src; attribute DOMString type; attribute DOMString width; attribute DOMString height; legacycaller any (any... arguments); };
Depending on the type of content instantiated by the
embed
element, the node may also support other
interfaces.
The embed
element represents an
integration point for an external (typically non-HTML) application
or interactive content.
The src
attribute
gives the address of the resource being embedded. The attribute, if
present, must contain a valid non-empty URL potentially
surrounded by spaces.
The type
attribute, if present, gives the MIME type by which the
plugin to instantiate is selected. The value must be a valid
MIME type. If both the type
attribute and the src
attribute are present, then the
type
attribute must specify the
same type as the explicit Content-Type
metadata of the resource given by the src
attribute.
When the element is created with neither a src
attribute nor a type
attribute, and when attributes
are removed such that neither attribute is present on the element
anymore, and when the element has a media element
ancestor, and when the element has an ancestor object
element that is not showing its fallback
content, any plugins instantiated for the element must be
removed, and the embed
element represents nothing.
An embed
element is said to be potentially active when the
following conditions are all met simultaneously:
Document
or was in a Document
the last time the event loop reached step 1.Document
is fully active.src
attribute set or a type
attribute set (or both).src
attribute is either absent or its value is not the empty string.object
element that is not showing its fallback content.Whenever an embed
element that was not potentially active becomes potentially active, and whenever
a potentially active
embed
element that is remaining potentially active and has its
src
attribute set, changed, or
removed or its type
attribute
set, changed, or removed, the appropriate set of steps from the
following list applies:
src
attribute setThe user agent must resolve
the value of the element's src
attribute, relative to the element. If that is successful, the
user agent should fetch the resulting
absolute URL, from the element's browsing
context scope origin if it has one. The task that is queued by the networking task source
once the resource has been fetched must
find and instantiate an appropriate plugin based on
the content's type, and
hand that plugin the content of the resource,
replacing any previously instantiated plugin for the element.
Fetching the resource must delay the load event of the element's document.
src
attribute setThe user agent should find and instantiate an appropriate
plugin based on the value of the type
attribute.
Whenever an embed
element that was potentially active stops being
potentially active, any
plugin that had been instantiated for that element must
be unloaded.
When a plugin is to be
instantiated but it cannot be secured and the sandboxed
plugins browsing context flag is set on the
embed
element's Document
's active
sandboxing flag set, then the user agent must not
instantiate the plugin, and must instead render the
embed
element in a manner that conveys that the
plugin was disabled. The user agent may offer the user
the option to override the sandbox and instantiate the
plugin anyway; if the user invokes such an option, the
user agent must act as if the conditions above did not apply for the
purposes of this element.
Plugins that cannot be secured are disabled in sandboxed browsing contexts because they might not honor the restrictions imposed by the sandbox (e.g. they might allow scripting even when scripting in the sandbox is disabled). User agents should convey the danger of overriding the sandbox to the user if an option to do so is provided.
The type of the content being embedded is defined as follows:
If the element has a type
attribute, and that attribute's
value is a type that a plugin supports, then the value
of the type
attribute is the
content's type.
Otherwise, if the <path> component of the URL of the specified resource (after any redirects) matches a pattern that a plugin supports, then the content's type is the type that that plugin can handle.
For example, a plugin might say that it can
handle resources with <path>
components that end with the four character string ".swf
".
Otherwise, if the specified resource has explicit Content-Type metadata, then that is the content's type.
Otherwise, the content has no type and there can be no appropriate plugin for it.
The embed
element has no fallback
content. If the user agent can't find a suitable plugin, then
the user agent must use a default plugin. (This default could be as
simple as saying "Unsupported Format".)
Whether the resource is fetched successfully or not (e.g. whether the response code was a 2xx code or equivalent) must be ignored when determining the resource's type and when handing the resource to the plugin.
This allows servers to return data for plugins even with error responses (e.g. HTTP 500 Internal Server Error codes can still contain plugin data).
Any namespace-less attribute other than name
, align
, hspace
, and vspace
may be specified on the embed
element,
so long as its name is XML-compatible and contains no
characters in the range U+0041 to U+005A (LATIN CAPITAL LETTER A to
LATIN CAPITAL LETTER Z). These attributes are then passed as
parameters to the plugin.
All attributes in HTML documents get lowercased automatically, so the restriction on uppercase letters doesn't affect such documents.
The four exceptions are to exclude legacy attributes that have side-effects beyond just sending parameters to the plugin.
The user agent should pass the names and values of all the
attributes of the embed
element that have no namespace
to the plugin used, when it is instantiated.
The HTMLEmbedElement
object representing the element
must expose the scriptable interface of the plugin
instantiated for the embed
element. At a minimum, this
interface must implement the legacy
caller operation. (It is suggested that the default behavior
of this legacy caller operation, e.g. the behavior of the default
plugin's legacy caller operation, be to throw a
NotSupportedError
exception.)
The embed
element supports dimension
attributes.
The IDL attributes src
and type
each must
reflect the respective content attributes of the same
name.
Here's a way to embed a resource that requires a proprietary plugin, like Flash:
<embed src="catgame.swf">
If the user does not have the plugin (for example if the plugin vendor doesn't support the user's platform), then the user will be unable to use the resource.
To pass the plugin a parameter "quality" with the value "high", an attribute can be specified:
<embed src="catgame.swf" quality="high">
This would be equivalent to the following, when using an
object
element instead:
<object data="catgame.swf"> <param name="quality" value="high"> </object>