#include "config.h"
#if ENABLE(VIDEO)
#include "MediaDocument.h"
#include "Chrome.h"
#include "ChromeClient.h"
#include "DocumentLoader.h"
#include "EventNames.h"
#include "ExceptionCodePlaceholder.h"
#include "Frame.h"
#include "FrameLoader.h"
#include "FrameLoaderClient.h"
#include "HTMLEmbedElement.h"
#include "HTMLHtmlElement.h"
#include "HTMLNames.h"
#include "HTMLSourceElement.h"
#include "HTMLVideoElement.h"
#include "KeyboardEvent.h"
#include "NodeList.h"
#include "Page.h"
#include "RawDataDocumentParser.h"
#include "ScriptController.h"
#include "ShadowRoot.h"
#include "TypedElementDescendantIterator.h"
namespace WebCore {
using namespace HTMLNames;
class MediaDocumentParser final : public RawDataDocumentParser {
public:
static Ref<MediaDocumentParser> create(MediaDocument& document)
{
return adoptRef(*new MediaDocumentParser(document));
}
private:
MediaDocumentParser(MediaDocument& document)
: RawDataDocumentParser(document)
, m_mediaElement(0)
{
m_outgoingReferrer = document.outgoingReferrer();
}
void appendBytes(DocumentWriter&, const char*, size_t) override;
void createDocumentStructure();
HTMLMediaElement* m_mediaElement;
String m_outgoingReferrer;
};
void MediaDocumentParser::createDocumentStructure()
{
auto rootElement = document()->createElement(htmlTag, false);
document()->appendChild(rootElement, IGNORE_EXCEPTION);
document()->setCSSTarget(rootElement.ptr());
downcast<HTMLHtmlElement>(rootElement.get()).insertedByParser();
if (document()->frame())
document()->frame()->injectUserScripts(InjectAtDocumentStart);
#if PLATFORM(IOS)
auto headElement = document()->createElement(headTag, false);
rootElement->appendChild(headElement, IGNORE_EXCEPTION);
auto metaElement = document()->createElement(metaTag, false);
metaElement->setAttributeWithoutSynchronization(nameAttr, AtomicString("viewport", AtomicString::ConstructFromLiteral));
metaElement->setAttributeWithoutSynchronization(contentAttr, AtomicString("width=device-width,initial-scale=1,user-scalable=no", AtomicString::ConstructFromLiteral));
headElement->appendChild(metaElement, IGNORE_EXCEPTION);
#endif
auto body = document()->createElement(bodyTag, false);
rootElement->appendChild(body, IGNORE_EXCEPTION);
auto mediaElement = document()->createElement(videoTag, false);
m_mediaElement = downcast<HTMLVideoElement>(mediaElement.ptr());
m_mediaElement->setAttributeWithoutSynchronization(controlsAttr, emptyAtom);
m_mediaElement->setAttributeWithoutSynchronization(autoplayAttr, emptyAtom);
m_mediaElement->setAttributeWithoutSynchronization(nameAttr, AtomicString("media", AtomicString::ConstructFromLiteral));
StringBuilder elementStyle;
elementStyle.appendLiteral("max-width: 100%; max-height: 100%;");
#if PLATFORM(IOS)
elementStyle.appendLiteral("width: 100%; height: 100%;");
#endif
m_mediaElement->setAttribute(styleAttr, elementStyle.toString());
auto sourceElement = document()->createElement(sourceTag, false);
HTMLSourceElement& source = downcast<HTMLSourceElement>(sourceElement.get());
source.setSrc(document()->url());
if (DocumentLoader* loader = document()->loader())
source.setType(loader->responseMIMEType());
m_mediaElement->appendChild(sourceElement, IGNORE_EXCEPTION);
body->appendChild(mediaElement, IGNORE_EXCEPTION);
Frame* frame = document()->frame();
if (!frame)
return;
frame->loader().activeDocumentLoader()->setMainResourceDataBufferingPolicy(DoNotBufferData);
frame->loader().setOutgoingReferrer(frame->document()->completeURL(m_outgoingReferrer));
}
void MediaDocumentParser::appendBytes(DocumentWriter&, const char*, size_t)
{
if (m_mediaElement)
return;
createDocumentStructure();
finish();
}
MediaDocument::MediaDocument(Frame* frame, const URL& url)
: HTMLDocument(frame, url, MediaDocumentClass)
, m_replaceMediaElementTimer(*this, &MediaDocument::replaceMediaElementTimerFired)
{
setCompatibilityMode(DocumentCompatibilityMode::QuirksMode);
lockCompatibilityMode();
if (frame)
m_outgoingReferrer = frame->loader().outgoingReferrer();
}
MediaDocument::~MediaDocument()
{
ASSERT(!m_replaceMediaElementTimer.isActive());
}
Ref<DocumentParser> MediaDocument::createParser()
{
return MediaDocumentParser::create(*this);
}
static inline HTMLVideoElement* descendantVideoElement(ContainerNode& node)
{
if (is<HTMLVideoElement>(node))
return downcast<HTMLVideoElement>(&node);
return descendantsOfType<HTMLVideoElement>(node).first();
}
static inline HTMLVideoElement* ancestorVideoElement(Node* node)
{
while (node && !is<HTMLVideoElement>(*node))
node = node->parentOrShadowHostNode();
return downcast<HTMLVideoElement>(node);
}
void MediaDocument::defaultEventHandler(Event* event)
{
Node* targetNode = event->target()->toNode();
if (!targetNode)
return;
if (HTMLVideoElement* video = ancestorVideoElement(targetNode)) {
if (event->type() == eventNames().clickEvent) {
if (!video->canPlay()) {
video->pause();
event->setDefaultHandled();
}
} else if (event->type() == eventNames().dblclickEvent) {
if (video->canPlay()) {
video->play();
event->setDefaultHandled();
}
}
}
if (!is<ContainerNode>(*targetNode))
return;
ContainerNode& targetContainer = downcast<ContainerNode>(*targetNode);
if (event->type() == eventNames().keydownEvent && is<KeyboardEvent>(*event)) {
HTMLVideoElement* video = descendantVideoElement(targetContainer);
if (!video)
return;
KeyboardEvent& keyboardEvent = downcast<KeyboardEvent>(*event);
if (keyboardEvent.keyIdentifier() == "U+0020") { if (video->paused()) {
if (video->canPlay())
video->play();
} else
video->pause();
keyboardEvent.setDefaultHandled();
}
}
}
void MediaDocument::mediaElementSawUnsupportedTracks()
{
m_replaceMediaElementTimer.startOneShot(0);
}
void MediaDocument::replaceMediaElementTimerFired()
{
auto* htmlBody = bodyOrFrameset();
if (!htmlBody)
return;
htmlBody->setAttributeWithoutSynchronization(marginwidthAttr, AtomicString("0", AtomicString::ConstructFromLiteral));
htmlBody->setAttributeWithoutSynchronization(marginheightAttr, AtomicString("0", AtomicString::ConstructFromLiteral));
if (HTMLVideoElement* videoElement = descendantVideoElement(*htmlBody)) {
RefPtr<Element> element = Document::createElement(embedTag, false);
HTMLEmbedElement& embedElement = downcast<HTMLEmbedElement>(*element);
embedElement.setAttributeWithoutSynchronization(widthAttr, AtomicString("100%", AtomicString::ConstructFromLiteral));
embedElement.setAttributeWithoutSynchronization(heightAttr, AtomicString("100%", AtomicString::ConstructFromLiteral));
embedElement.setAttributeWithoutSynchronization(nameAttr, AtomicString("plugin", AtomicString::ConstructFromLiteral));
embedElement.setAttributeWithoutSynchronization(srcAttr, url().string());
DocumentLoader* documentLoader = loader();
ASSERT(documentLoader);
if (documentLoader)
embedElement.setAttributeWithoutSynchronization(typeAttr, documentLoader->writer().mimeType());
videoElement->parentNode()->replaceChild(embedElement, *videoElement, IGNORE_EXCEPTION);
}
}
void MediaDocument::mediaElementNaturalSizeChanged(const IntSize& newSize)
{
if (ownerElement())
return;
if (newSize.isZero())
return;
if (page())
page()->chrome().client().imageOrMediaDocumentSizeChanged(newSize);
}
}
#endif