| Index: sky/engine/core/html/HTMLMediaElement.cpp
|
| diff --git a/sky/engine/core/html/HTMLMediaElement.cpp b/sky/engine/core/html/HTMLMediaElement.cpp
|
| deleted file mode 100644
|
| index 205e7fe1d35dc27c8f8f27fd5f94641ae4781f2d..0000000000000000000000000000000000000000
|
| --- a/sky/engine/core/html/HTMLMediaElement.cpp
|
| +++ /dev/null
|
| @@ -1,2414 +0,0 @@
|
| -/*
|
| - * Copyright (C) 2007, 2008, 2009, 2010, 2011, 2012, 2013 Apple Inc. All rights reserved.
|
| - *
|
| - * Redistribution and use in source and binary forms, with or without
|
| - * modification, are permitted provided that the following conditions
|
| - * are met:
|
| - * 1. Redistributions of source code must retain the above copyright
|
| - * notice, this list of conditions and the following disclaimer.
|
| - * 2. Redistributions in binary form must reproduce the above copyright
|
| - * notice, this list of conditions and the following disclaimer in the
|
| - * documentation and/or other materials provided with the distribution.
|
| - *
|
| - * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
|
| - * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
| - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
|
| - * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE COMPUTER, INC. OR
|
| - * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
|
| - * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
|
| - * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
|
| - * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
|
| - * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
| - * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
| - * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
| - */
|
| -
|
| -#include "config.h"
|
| -#include "core/html/HTMLMediaElement.h"
|
| -
|
| -#include "bindings/core/v8/ExceptionMessages.h"
|
| -#include "bindings/core/v8/ExceptionState.h"
|
| -#include "bindings/core/v8/ExceptionStatePlaceholder.h"
|
| -#include "bindings/core/v8/ScriptController.h"
|
| -#include "core/HTMLNames.h"
|
| -#include "core/css/MediaList.h"
|
| -#include "core/dom/Attribute.h"
|
| -#include "core/dom/ElementTraversal.h"
|
| -#include "core/dom/ExceptionCode.h"
|
| -#include "core/events/Event.h"
|
| -#include "core/frame/LocalFrame.h"
|
| -#include "core/frame/Settings.h"
|
| -#include "core/frame/UseCounter.h"
|
| -#include "core/html/HTMLMediaSource.h"
|
| -#include "core/html/HTMLSourceElement.h"
|
| -#include "core/html/MediaError.h"
|
| -#include "core/html/MediaFragmentURIParser.h"
|
| -#include "core/html/TimeRanges.h"
|
| -#include "core/rendering/RenderView.h"
|
| -#include "core/rendering/compositing/RenderLayerCompositor.h"
|
| -#include "platform/ContentType.h"
|
| -#include "platform/Language.h"
|
| -#include "platform/Logging.h"
|
| -#include "platform/MIMETypeFromURL.h"
|
| -#include "platform/MIMETypeRegistry.h"
|
| -#include "platform/NotImplemented.h"
|
| -#include "platform/RuntimeEnabledFeatures.h"
|
| -#include "platform/UserGestureIndicator.h"
|
| -#include "platform/graphics/GraphicsLayer.h"
|
| -#include "public/platform/Platform.h"
|
| -#include "wtf/CurrentTime.h"
|
| -#include "wtf/MathExtras.h"
|
| -#include "wtf/NonCopyingSort.h"
|
| -#include "wtf/Uint8Array.h"
|
| -#include "wtf/text/CString.h"
|
| -#include <limits>
|
| -
|
| -using blink::WebMediaPlayer;
|
| -using blink::WebMimeRegistry;
|
| -using blink::WebMediaPlayerClient;
|
| -
|
| -namespace blink {
|
| -
|
| -#if !LOG_DISABLED
|
| -static String urlForLoggingMedia(const KURL& url)
|
| -{
|
| - static const unsigned maximumURLLengthForLogging = 128;
|
| -
|
| - if (url.string().length() < maximumURLLengthForLogging)
|
| - return url.string();
|
| - return url.string().substring(0, maximumURLLengthForLogging) + "...";
|
| -}
|
| -
|
| -static const char* boolString(bool val)
|
| -{
|
| - return val ? "true" : "false";
|
| -}
|
| -#endif
|
| -
|
| -#ifndef LOG_MEDIA_EVENTS
|
| -// Default to not logging events because so many are generated they can overwhelm the rest of
|
| -// the logging.
|
| -#define LOG_MEDIA_EVENTS 0
|
| -#endif
|
| -
|
| -#ifndef LOG_CACHED_TIME_WARNINGS
|
| -// Default to not logging warnings about excessive drift in the cached media time because it adds a
|
| -// fair amount of overhead and logging.
|
| -#define LOG_CACHED_TIME_WARNINGS 0
|
| -#endif
|
| -
|
| -typedef HashSet<RawPtr<HTMLMediaElement> > WeakMediaElementSet;
|
| -typedef HashMap<RawPtr<Document>, WeakMediaElementSet> DocumentElementSetMap;
|
| -static DocumentElementSetMap& documentToElementSetMap()
|
| -{
|
| - DEFINE_STATIC_LOCAL(OwnPtr<DocumentElementSetMap>, map, (adoptPtr(new DocumentElementSetMap())));
|
| - return *map;
|
| -}
|
| -
|
| -static void addElementToDocumentMap(HTMLMediaElement* element, Document* document)
|
| -{
|
| - DocumentElementSetMap& map = documentToElementSetMap();
|
| - WeakMediaElementSet set = map.take(document);
|
| - set.add(element);
|
| - map.add(document, set);
|
| -}
|
| -
|
| -static void removeElementFromDocumentMap(HTMLMediaElement* element, Document* document)
|
| -{
|
| - DocumentElementSetMap& map = documentToElementSetMap();
|
| - WeakMediaElementSet set = map.take(document);
|
| - set.remove(element);
|
| - if (!set.isEmpty())
|
| - map.add(document, set);
|
| -}
|
| -
|
| -static bool canLoadURL(const KURL& url, const ContentType& contentType, const String& keySystem)
|
| -{
|
| - DEFINE_STATIC_LOCAL(const String, codecs, ("codecs"));
|
| -
|
| - String contentMIMEType = contentType.type().lower();
|
| - String contentTypeCodecs = contentType.parameter(codecs);
|
| -
|
| - // If the MIME type is missing or is not meaningful, try to figure it out from the URL.
|
| - if (contentMIMEType.isEmpty() || contentMIMEType == "application/octet-stream" || contentMIMEType == "text/plain") {
|
| - if (url.protocolIsData())
|
| - contentMIMEType = mimeTypeFromDataURL(url.string());
|
| - }
|
| -
|
| - // If no MIME type is specified, always attempt to load.
|
| - if (contentMIMEType.isEmpty())
|
| - return true;
|
| -
|
| - // 4.8.10.3 MIME types - In the absence of a specification to the contrary, the MIME type "application/octet-stream"
|
| - // when used with parameters, e.g. "application/octet-stream;codecs=theora", is a type that the user agent knows
|
| - // it cannot render.
|
| - if (contentMIMEType != "application/octet-stream" || contentTypeCodecs.isEmpty()) {
|
| - WebMimeRegistry::SupportsType supported = blink::Platform::current()->mimeRegistry()->supportsMediaMIMEType(contentMIMEType, contentTypeCodecs, keySystem.lower());
|
| - return supported > WebMimeRegistry::IsNotSupported;
|
| - }
|
| -
|
| - return false;
|
| -}
|
| -
|
| -WebMimeRegistry::SupportsType HTMLMediaElement::supportsType(const ContentType& contentType, const String& keySystem)
|
| -{
|
| - DEFINE_STATIC_LOCAL(const String, codecs, ("codecs"));
|
| -
|
| - if (!RuntimeEnabledFeatures::mediaEnabled())
|
| - return WebMimeRegistry::IsNotSupported;
|
| -
|
| - String type = contentType.type().lower();
|
| - // The codecs string is not lower-cased because MP4 values are case sensitive
|
| - // per http://tools.ietf.org/html/rfc4281#page-7.
|
| - String typeCodecs = contentType.parameter(codecs);
|
| - String system = keySystem.lower();
|
| -
|
| - if (type.isEmpty())
|
| - return WebMimeRegistry::IsNotSupported;
|
| -
|
| - // 4.8.10.3 MIME types - The canPlayType(type) method must return the empty string if type is a type that the
|
| - // user agent knows it cannot render or is the type "application/octet-stream"
|
| - if (type == "application/octet-stream")
|
| - return WebMimeRegistry::IsNotSupported;
|
| -
|
| - return blink::Platform::current()->mimeRegistry()->supportsMediaMIMEType(type, typeCodecs, system);
|
| -}
|
| -
|
| -HTMLMediaElement::HTMLMediaElement(const QualifiedName& tagName, Document& document)
|
| - : HTMLElement(tagName, document)
|
| - , ActiveDOMObject(&document)
|
| - , m_loadTimer(this, &HTMLMediaElement::loadTimerFired)
|
| - , m_progressEventTimer(this, &HTMLMediaElement::progressEventTimerFired)
|
| - , m_playbackProgressTimer(this, &HTMLMediaElement::playbackProgressTimerFired)
|
| - , m_playedTimeRanges()
|
| - , m_asyncEventQueue(GenericEventQueue::create(this))
|
| - , m_playbackRate(1.0f)
|
| - , m_defaultPlaybackRate(1.0f)
|
| - , m_networkState(NETWORK_EMPTY)
|
| - , m_readyState(HAVE_NOTHING)
|
| - , m_readyStateMaximum(HAVE_NOTHING)
|
| - , m_volume(1.0f)
|
| - , m_lastSeekTime(0)
|
| - , m_previousProgressTime(std::numeric_limits<double>::max())
|
| - , m_duration(std::numeric_limits<double>::quiet_NaN())
|
| - , m_lastTimeUpdateEventWallTime(0)
|
| - , m_lastTimeUpdateEventMovieTime(std::numeric_limits<double>::max())
|
| - , m_loadState(WaitingForSource)
|
| - , m_deferredLoadState(NotDeferred)
|
| - , m_deferredLoadTimer(this, &HTMLMediaElement::deferredLoadTimerFired)
|
| - , m_webLayer(0)
|
| - , m_preload(MediaPlayer::Auto)
|
| - , m_displayMode(Unknown)
|
| - , m_cachedTime(MediaPlayer::invalidTime())
|
| - , m_fragmentStartTime(MediaPlayer::invalidTime())
|
| - , m_fragmentEndTime(MediaPlayer::invalidTime())
|
| - , m_pendingActionFlags(0)
|
| - , m_userGestureRequiredForPlay(false)
|
| - , m_playing(false)
|
| - , m_shouldDelayLoadEvent(false)
|
| - , m_haveFiredLoadedData(false)
|
| - , m_active(true)
|
| - , m_autoplaying(true)
|
| - , m_muted(false)
|
| - , m_paused(true)
|
| - , m_seeking(false)
|
| - , m_sentStalledEvent(false)
|
| - , m_sentEndEvent(false)
|
| - , m_pausedInternal(false)
|
| - , m_closedCaptionsVisible(false)
|
| - , m_completelyLoaded(false)
|
| - , m_havePreparedToPlay(false)
|
| - , m_processingPreferenceChange(false)
|
| -#if ENABLE(OILPAN)
|
| - , m_isFinalizing(false)
|
| - , m_closeMediaSourceWhenFinalizing(false)
|
| -#endif
|
| -{
|
| - ASSERT(RuntimeEnabledFeatures::mediaEnabled());
|
| -
|
| - WTF_LOG(Media, "HTMLMediaElement::HTMLMediaElement");
|
| - ScriptWrappable::init(this);
|
| -
|
| - if (document.settings() && document.settings()->mediaPlaybackRequiresUserGesture())
|
| - m_userGestureRequiredForPlay = true;
|
| -
|
| - setHasCustomStyleCallbacks();
|
| - addElementToDocumentMap(this, &document);
|
| -}
|
| -
|
| -HTMLMediaElement::~HTMLMediaElement()
|
| -{
|
| - WTF_LOG(Media, "HTMLMediaElement::~HTMLMediaElement");
|
| -
|
| -#if ENABLE(OILPAN)
|
| - // If the HTMLMediaElement dies with the document we are not
|
| - // allowed to touch the document to adjust delay load event counts
|
| - // because the document could have been already
|
| - // destructed. However, if the HTMLMediaElement dies with the
|
| - // document there is no need to change the delayed load counts
|
| - // because no load event will fire anyway. If the document is
|
| - // still alive we do have to decrement the load delay counts. We
|
| - // determine if the document is alive via the ActiveDOMObject
|
| - // which is a context lifecycle observer. If the Document has been
|
| - // destructed ActiveDOMObject::executionContext() returns 0.
|
| - if (ActiveDOMObject::executionContext())
|
| - setShouldDelayLoadEvent(false);
|
| -#else
|
| - // HTMLMediaElement and m_asyncEventQueue always become unreachable
|
| - // together. So HTMLMediaElemenet and m_asyncEventQueue are destructed in
|
| - // the same GC. We don't need to close it explicitly in Oilpan.
|
| - m_asyncEventQueue->close();
|
| -
|
| - setShouldDelayLoadEvent(false);
|
| -#endif
|
| -
|
| -#if ENABLE(OILPAN)
|
| - if (m_closeMediaSourceWhenFinalizing)
|
| - closeMediaSource();
|
| -#else
|
| - closeMediaSource();
|
| -
|
| - removeElementFromDocumentMap(this, &document());
|
| -#endif
|
| -
|
| - // Destroying the player may cause a resource load to be canceled,
|
| - // which could result in userCancelledLoad() being called back.
|
| - // Setting m_completelyLoaded ensures that such a call will not cause
|
| - // us to dispatch an abort event, which would result in a crash.
|
| - // See http://crbug.com/233654 for more details.
|
| - m_completelyLoaded = true;
|
| -
|
| - // With Oilpan load events on the Document are always delayed during
|
| - // sweeping so we don't need to explicitly increment and decrement
|
| - // load event delay counts.
|
| -#if !ENABLE(OILPAN)
|
| - // Destroying the player may cause a resource load to be canceled,
|
| - // which could result in Document::dispatchWindowLoadEvent() being
|
| - // called via ResourceFetch::didLoadResource() then
|
| - // FrameLoader::loadDone(). To prevent load event dispatching during
|
| - // object destruction, we use Document::incrementLoadEventDelayCount().
|
| - // See http://crbug.com/275223 for more details.
|
| - document().incrementLoadEventDelayCount();
|
| -#endif
|
| -
|
| -#if ENABLE(OILPAN)
|
| - // Oilpan: the player must be released, but the player object
|
| - // cannot safely access this player client any longer as parts of
|
| - // it may have been finalized already (like the media element's
|
| - // supplementable table.) Handled for now by entering an
|
| - // is-finalizing state, which is explicitly checked for if the
|
| - // player tries to access the media element during shutdown.
|
| - //
|
| - // FIXME: Oilpan: move the media player to the heap instead and
|
| - // avoid having to finalize it from here; this whole #if block
|
| - // could then be removed (along with the state bit it depends on.)
|
| - // crbug.com/378229
|
| - m_isFinalizing = true;
|
| -#endif
|
| -
|
| - clearMediaPlayerAndAudioSourceProviderClientWithoutLocking();
|
| -
|
| -#if !ENABLE(OILPAN)
|
| - document().decrementLoadEventDelayCount();
|
| -#endif
|
| -}
|
| -
|
| -#if ENABLE(OILPAN)
|
| -void HTMLMediaElement::setCloseMediaSourceWhenFinalizing()
|
| -{
|
| - ASSERT(!m_closeMediaSourceWhenFinalizing);
|
| - m_closeMediaSourceWhenFinalizing = true;
|
| -}
|
| -#endif
|
| -
|
| -void HTMLMediaElement::didMoveToNewDocument(Document& oldDocument)
|
| -{
|
| - WTF_LOG(Media, "HTMLMediaElement::didMoveToNewDocument");
|
| -
|
| - if (m_shouldDelayLoadEvent) {
|
| - document().incrementLoadEventDelayCount();
|
| - // Note: Keeping the load event delay count increment on oldDocument that was added
|
| - // when m_shouldDelayLoadEvent was set so that destruction of m_player can not
|
| - // cause load event dispatching in oldDocument.
|
| - } else {
|
| - // Incrementing the load event delay count so that destruction of m_player can not
|
| - // cause load event dispatching in oldDocument.
|
| - oldDocument.incrementLoadEventDelayCount();
|
| - }
|
| -
|
| - removeElementFromDocumentMap(this, &oldDocument);
|
| - addElementToDocumentMap(this, &document());
|
| -
|
| - // FIXME: This is a temporary fix to prevent this object from causing the
|
| - // MediaPlayer to dereference LocalFrame and FrameLoader pointers from the
|
| - // previous document. A proper fix would provide a mechanism to allow this
|
| - // object to refresh the MediaPlayer's LocalFrame and FrameLoader references on
|
| - // document changes so that playback can be resumed properly.
|
| - userCancelledLoad();
|
| -
|
| - // Decrement the load event delay count on oldDocument now that m_player has been destroyed
|
| - // and there is no risk of dispatching a load event from within the destructor.
|
| - oldDocument.decrementLoadEventDelayCount();
|
| -
|
| - ActiveDOMObject::didMoveToNewExecutionContext(&document());
|
| - HTMLElement::didMoveToNewDocument(oldDocument);
|
| -}
|
| -
|
| -bool HTMLMediaElement::isMouseFocusable() const
|
| -{
|
| - return false;
|
| -}
|
| -
|
| -void HTMLMediaElement::parseAttribute(const QualifiedName& name, const AtomicString& value)
|
| -{
|
| - if (name == HTMLNames::srcAttr) {
|
| - // Trigger a reload, as long as the 'src' attribute is present.
|
| - if (!value.isNull()) {
|
| - clearMediaPlayer(LoadMediaResource);
|
| - scheduleDelayedAction(LoadMediaResource);
|
| - }
|
| - } else if (name == HTMLNames::preloadAttr) {
|
| - if (equalIgnoringCase(value, "none"))
|
| - m_preload = MediaPlayer::None;
|
| - else if (equalIgnoringCase(value, "metadata"))
|
| - m_preload = MediaPlayer::MetaData;
|
| - else {
|
| - // The spec does not define an "invalid value default" but "auto" is suggested as the
|
| - // "missing value default", so use it for everything except "none" and "metadata"
|
| - m_preload = MediaPlayer::Auto;
|
| - }
|
| -
|
| - // The attribute must be ignored if the autoplay attribute is present
|
| - if (!autoplay() && m_player)
|
| - setPlayerPreload();
|
| - }
|
| -
|
| - HTMLElement::parseAttribute(name, value);
|
| -}
|
| -
|
| -void HTMLMediaElement::finishParsingChildren()
|
| -{
|
| - HTMLElement::finishParsingChildren();
|
| -}
|
| -
|
| -bool HTMLMediaElement::rendererIsNeeded(const RenderStyle& style)
|
| -{
|
| - // FIXME(sky): Can we delete this method?
|
| - return false;
|
| -}
|
| -
|
| -RenderObject* HTMLMediaElement::createRenderer(RenderStyle*)
|
| -{
|
| - return 0;
|
| -}
|
| -
|
| -Node::InsertionNotificationRequest HTMLMediaElement::insertedInto(ContainerNode* insertionPoint)
|
| -{
|
| - WTF_LOG(Media, "HTMLMediaElement::insertedInto");
|
| -
|
| - HTMLElement::insertedInto(insertionPoint);
|
| - if (insertionPoint->inDocument()) {
|
| - m_active = true;
|
| -
|
| - if (!getAttribute(HTMLNames::srcAttr).isEmpty() && m_networkState == NETWORK_EMPTY)
|
| - scheduleDelayedAction(LoadMediaResource);
|
| - }
|
| -
|
| - return InsertionShouldCallDidNotifySubtreeInsertions;
|
| -}
|
| -
|
| -void HTMLMediaElement::didNotifySubtreeInsertionsToDocument()
|
| -{
|
| -}
|
| -
|
| -void HTMLMediaElement::removedFrom(ContainerNode* insertionPoint)
|
| -{
|
| - WTF_LOG(Media, "HTMLMediaElement::removedFrom");
|
| -
|
| - m_active = false;
|
| - if (insertionPoint->inDocument() && insertionPoint->document().isActive()) {
|
| - if (m_networkState > NETWORK_EMPTY)
|
| - pause();
|
| - }
|
| -
|
| - HTMLElement::removedFrom(insertionPoint);
|
| -}
|
| -
|
| -void HTMLMediaElement::attach(const AttachContext& context)
|
| -{
|
| - HTMLElement::attach(context);
|
| -
|
| - if (renderer())
|
| - renderer()->updateFromElement();
|
| -}
|
| -
|
| -void HTMLMediaElement::didRecalcStyle(StyleRecalcChange)
|
| -{
|
| - if (renderer())
|
| - renderer()->updateFromElement();
|
| -}
|
| -
|
| -void HTMLMediaElement::scheduleDelayedAction(DelayedActionType actionType)
|
| -{
|
| - WTF_LOG(Media, "HTMLMediaElement::scheduleDelayedAction");
|
| -
|
| - if ((actionType & LoadMediaResource) && !(m_pendingActionFlags & LoadMediaResource)) {
|
| - prepareForLoad();
|
| - m_pendingActionFlags |= LoadMediaResource;
|
| - }
|
| -
|
| - if (!m_loadTimer.isActive())
|
| - m_loadTimer.startOneShot(0, FROM_HERE);
|
| -}
|
| -
|
| -void HTMLMediaElement::scheduleNextSourceChild()
|
| -{
|
| - // Schedule the timer to try the next <source> element WITHOUT resetting state ala prepareForLoad.
|
| - m_pendingActionFlags |= LoadMediaResource;
|
| - m_loadTimer.startOneShot(0, FROM_HERE);
|
| -}
|
| -
|
| -void HTMLMediaElement::scheduleEvent(const AtomicString& eventName)
|
| -{
|
| - scheduleEvent(Event::createCancelable(eventName));
|
| -}
|
| -
|
| -void HTMLMediaElement::scheduleEvent(PassRefPtr<Event> event)
|
| -{
|
| -#if LOG_MEDIA_EVENTS
|
| - WTF_LOG(Media, "HTMLMediaElement::scheduleEvent - scheduling '%s'", event->type().ascii().data());
|
| -#endif
|
| - m_asyncEventQueue->enqueueEvent(event);
|
| -}
|
| -
|
| -void HTMLMediaElement::loadTimerFired(Timer<HTMLMediaElement>*)
|
| -{
|
| - if (m_pendingActionFlags & LoadMediaResource) {
|
| - if (m_loadState == LoadingFromSourceElement)
|
| - loadNextSourceChild();
|
| - else
|
| - loadInternal();
|
| - }
|
| -
|
| - m_pendingActionFlags = 0;
|
| -}
|
| -
|
| -PassRefPtr<MediaError> HTMLMediaElement::error() const
|
| -{
|
| - return m_error;
|
| -}
|
| -
|
| -void HTMLMediaElement::setSrc(const AtomicString& url)
|
| -{
|
| - setAttribute(HTMLNames::srcAttr, url);
|
| -}
|
| -
|
| -HTMLMediaElement::NetworkState HTMLMediaElement::networkState() const
|
| -{
|
| - return m_networkState;
|
| -}
|
| -
|
| -String HTMLMediaElement::canPlayType(const String& mimeType, const String& keySystem) const
|
| -{
|
| - if (!keySystem.isNull())
|
| - UseCounter::count(document(), UseCounter::CanPlayTypeKeySystem);
|
| -
|
| - WebMimeRegistry::SupportsType support = supportsType(ContentType(mimeType), keySystem);
|
| - String canPlay;
|
| -
|
| - // 4.8.10.3
|
| - switch (support)
|
| - {
|
| - case WebMimeRegistry::IsNotSupported:
|
| - canPlay = emptyString();
|
| - break;
|
| - case WebMimeRegistry::MayBeSupported:
|
| - canPlay = "maybe";
|
| - break;
|
| - case WebMimeRegistry::IsSupported:
|
| - canPlay = "probably";
|
| - break;
|
| - }
|
| -
|
| - WTF_LOG(Media, "HTMLMediaElement::canPlayType(%s, %s) -> %s", mimeType.utf8().data(), keySystem.utf8().data(), canPlay.utf8().data());
|
| -
|
| - return canPlay;
|
| -}
|
| -
|
| -void HTMLMediaElement::load()
|
| -{
|
| - WTF_LOG(Media, "HTMLMediaElement::load()");
|
| -
|
| - if (UserGestureIndicator::processingUserGesture())
|
| - m_userGestureRequiredForPlay = false;
|
| -
|
| - prepareForLoad();
|
| - loadInternal();
|
| - prepareToPlay();
|
| -}
|
| -
|
| -void HTMLMediaElement::prepareForLoad()
|
| -{
|
| - WTF_LOG(Media, "HTMLMediaElement::prepareForLoad");
|
| -
|
| - // Perform the cleanup required for the resource load algorithm to run.
|
| - stopPeriodicTimers();
|
| - m_loadTimer.stop();
|
| - cancelDeferredLoad();
|
| - // FIXME: Figure out appropriate place to reset LoadTextTrackResource if necessary and set m_pendingActionFlags to 0 here.
|
| - m_pendingActionFlags &= ~LoadMediaResource;
|
| - m_sentEndEvent = false;
|
| - m_sentStalledEvent = false;
|
| - m_haveFiredLoadedData = false;
|
| - m_completelyLoaded = false;
|
| - m_havePreparedToPlay = false;
|
| - m_displayMode = Unknown;
|
| -
|
| - // 1 - Abort any already-running instance of the resource selection algorithm for this element.
|
| - m_loadState = WaitingForSource;
|
| - m_currentSourceNode = nullptr;
|
| -
|
| - // 2 - If there are any tasks from the media element's media element event task source in
|
| - // one of the task queues, then remove those tasks.
|
| - cancelPendingEventsAndCallbacks();
|
| -
|
| - // 3 - If the media element's networkState is set to NETWORK_LOADING or NETWORK_IDLE, queue
|
| - // a task to fire a simple event named abort at the media element.
|
| - if (m_networkState == NETWORK_LOADING || m_networkState == NETWORK_IDLE)
|
| - scheduleEvent(EventTypeNames::abort);
|
| -
|
| - createMediaPlayer();
|
| -
|
| - // 4 - If the media element's networkState is not set to NETWORK_EMPTY, then run these substeps
|
| - if (m_networkState != NETWORK_EMPTY) {
|
| - // 4.1 - Queue a task to fire a simple event named emptied at the media element.
|
| - scheduleEvent(EventTypeNames::emptied);
|
| -
|
| - // 4.2 - If a fetching process is in progress for the media element, the user agent should stop it.
|
| - m_networkState = NETWORK_EMPTY;
|
| -
|
| - // 4.3 - Forget the media element's media-resource-specific tracks.
|
| - // FIXME(sky): We have no tracks.
|
| -
|
| - // 4.4 - If readyState is not set to HAVE_NOTHING, then set it to that state.
|
| - m_readyState = HAVE_NOTHING;
|
| - m_readyStateMaximum = HAVE_NOTHING;
|
| -
|
| - // 4.5 - If the paused attribute is false, then set it to true.
|
| - m_paused = true;
|
| -
|
| - // 4.6 - If seeking is true, set it to false.
|
| - m_seeking = false;
|
| -
|
| - // 4.7 - Set the current playback position to 0.
|
| - // Set the official playback position to 0.
|
| - // If this changed the official playback position, then queue a task to fire a simple event named timeupdate at the media element.
|
| - // FIXME: Add support for firing this event.
|
| -
|
| - // 4.8 - Set the initial playback position to 0.
|
| - // FIXME: Make this less subtle. The position only becomes 0 because the ready state is HAVE_NOTHING.
|
| - invalidateCachedTime();
|
| -
|
| - // 4.9 - Set the timeline offset to Not-a-Number (NaN).
|
| - // 4.10 - Update the duration attribute to Not-a-Number (NaN).
|
| - }
|
| -
|
| - // 5 - Set the playbackRate attribute to the value of the defaultPlaybackRate attribute.
|
| - setPlaybackRate(defaultPlaybackRate());
|
| -
|
| - // 6 - Set the error attribute to null and the autoplaying flag to true.
|
| - m_error = nullptr;
|
| - m_autoplaying = true;
|
| -
|
| - // 7 - Invoke the media element's resource selection algorithm.
|
| -
|
| - // 8 - Note: Playback of any previously playing media resource for this element stops.
|
| -
|
| - // The resource selection algorithm
|
| - // 1 - Set the networkState to NETWORK_NO_SOURCE
|
| - m_networkState = NETWORK_NO_SOURCE;
|
| -
|
| - // 2 - Asynchronously await a stable state.
|
| -
|
| - m_playedTimeRanges = TimeRanges::create();
|
| -
|
| - // FIXME: Investigate whether these can be moved into m_networkState != NETWORK_EMPTY block above
|
| - // so they are closer to the relevant spec steps.
|
| - m_lastSeekTime = 0;
|
| - m_duration = std::numeric_limits<double>::quiet_NaN();
|
| -
|
| - // The spec doesn't say to block the load event until we actually run the asynchronous section
|
| - // algorithm, but do it now because we won't start that until after the timer fires and the
|
| - // event may have already fired by then.
|
| - setShouldDelayLoadEvent(true);
|
| -}
|
| -
|
| -void HTMLMediaElement::loadInternal()
|
| -{
|
| - selectMediaResource();
|
| -}
|
| -
|
| -void HTMLMediaElement::selectMediaResource()
|
| -{
|
| - WTF_LOG(Media, "HTMLMediaElement::selectMediaResource");
|
| -
|
| - enum Mode { attribute, children };
|
| -
|
| - // 3 - If the media element has a src attribute, then let mode be attribute.
|
| - Mode mode = attribute;
|
| - if (!hasAttribute(HTMLNames::srcAttr)) {
|
| - // Otherwise, if the media element does not have a src attribute but has a source
|
| - // element child, then let mode be children and let candidate be the first such
|
| - // source element child in tree order.
|
| - if (HTMLSourceElement* element = Traversal<HTMLSourceElement>::firstChild(*this)) {
|
| - mode = children;
|
| - m_nextChildNodeToConsider = element;
|
| - m_currentSourceNode = nullptr;
|
| - } else {
|
| - // Otherwise the media element has neither a src attribute nor a source element
|
| - // child: set the networkState to NETWORK_EMPTY, and abort these steps; the
|
| - // synchronous section ends.
|
| - m_loadState = WaitingForSource;
|
| - setShouldDelayLoadEvent(false);
|
| - m_networkState = NETWORK_EMPTY;
|
| -
|
| - WTF_LOG(Media, "HTMLMediaElement::selectMediaResource, nothing to load");
|
| - return;
|
| - }
|
| - }
|
| -
|
| - // 4 - Set the media element's delaying-the-load-event flag to true (this delays the load event),
|
| - // and set its networkState to NETWORK_LOADING.
|
| - setShouldDelayLoadEvent(true);
|
| - m_networkState = NETWORK_LOADING;
|
| -
|
| - // 5 - Queue a task to fire a simple event named loadstart at the media element.
|
| - scheduleEvent(EventTypeNames::loadstart);
|
| -
|
| - // 6 - If mode is attribute, then run these substeps
|
| - if (mode == attribute) {
|
| - m_loadState = LoadingFromSrcAttr;
|
| -
|
| - // If the src attribute's value is the empty string ... jump down to the failed step below
|
| - KURL mediaURL = getNonEmptyURLAttribute(HTMLNames::srcAttr);
|
| - if (mediaURL.isEmpty()) {
|
| - mediaLoadingFailed(WebMediaPlayer::NetworkStateFormatError);
|
| - WTF_LOG(Media, "HTMLMediaElement::selectMediaResource, empty 'src'");
|
| - return;
|
| - }
|
| -
|
| - if (!isSafeToLoadURL(mediaURL, Complain)) {
|
| - mediaLoadingFailed(WebMediaPlayer::NetworkStateFormatError);
|
| - return;
|
| - }
|
| -
|
| - // No type or key system information is available when the url comes
|
| - // from the 'src' attribute so MediaPlayer
|
| - // will have to pick a media engine based on the file extension.
|
| - ContentType contentType((String()));
|
| - loadResource(mediaURL, contentType, String());
|
| - WTF_LOG(Media, "HTMLMediaElement::selectMediaResource, using 'src' attribute url");
|
| - return;
|
| - }
|
| -
|
| - // Otherwise, the source elements will be used
|
| - loadNextSourceChild();
|
| -}
|
| -
|
| -void HTMLMediaElement::loadNextSourceChild()
|
| -{
|
| - ContentType contentType((String()));
|
| - String keySystem;
|
| - KURL mediaURL = selectNextSourceChild(&contentType, &keySystem, Complain);
|
| - if (!mediaURL.isValid()) {
|
| - waitForSourceChange();
|
| - return;
|
| - }
|
| -
|
| - // Recreate the media player for the new url
|
| - createMediaPlayer();
|
| -
|
| - m_loadState = LoadingFromSourceElement;
|
| - loadResource(mediaURL, contentType, keySystem);
|
| -}
|
| -
|
| -void HTMLMediaElement::loadResource(const KURL& url, ContentType& contentType, const String& keySystem)
|
| -{
|
| - ASSERT(isSafeToLoadURL(url, Complain));
|
| -
|
| - WTF_LOG(Media, "HTMLMediaElement::loadResource(%s, %s, %s)", urlForLoggingMedia(url).utf8().data(), contentType.raw().utf8().data(), keySystem.utf8().data());
|
| -
|
| - LocalFrame* frame = document().frame();
|
| - if (!frame) {
|
| - mediaLoadingFailed(WebMediaPlayer::NetworkStateFormatError);
|
| - return;
|
| - }
|
| -
|
| - // The resource fetch algorithm
|
| - m_networkState = NETWORK_LOADING;
|
| -
|
| - // Set m_currentSrc *before* changing to the cache url, the fact that we are loading from the app
|
| - // cache is an internal detail not exposed through the media element API.
|
| - m_currentSrc = url;
|
| -
|
| - WTF_LOG(Media, "HTMLMediaElement::loadResource - m_currentSrc -> %s", urlForLoggingMedia(m_currentSrc).utf8().data());
|
| -
|
| - startProgressEventTimer();
|
| -
|
| - // Reset display mode to force a recalculation of what to show because we are resetting the player.
|
| - setDisplayMode(Unknown);
|
| -
|
| - if (!autoplay())
|
| - setPlayerPreload();
|
| -
|
| - if (hasAttribute(HTMLNames::mutedAttr))
|
| - m_muted = true;
|
| - updateVolume();
|
| -
|
| - ASSERT(!m_mediaSource);
|
| -
|
| - bool attemptLoad = true;
|
| -
|
| - if (attemptLoad && canLoadURL(url, contentType, keySystem)) {
|
| - ASSERT(!webMediaPlayer());
|
| -
|
| - if (!m_havePreparedToPlay && !autoplay() && m_preload == MediaPlayer::None) {
|
| - WTF_LOG(Media, "HTMLMediaElement::loadResource : Delaying load because preload == 'none'");
|
| - deferLoad();
|
| - } else {
|
| - startPlayerLoad();
|
| - }
|
| - } else {
|
| - mediaLoadingFailed(WebMediaPlayer::NetworkStateFormatError);
|
| - }
|
| -
|
| - // If there is no poster to display, allow the media engine to render video frames as soon as
|
| - // they are available.
|
| - updateDisplayState();
|
| -
|
| - if (renderer())
|
| - renderer()->updateFromElement();
|
| -}
|
| -
|
| -void HTMLMediaElement::startPlayerLoad()
|
| -{
|
| - // Filter out user:pass as those two URL components aren't
|
| - // considered for media resource fetches (including for the CORS
|
| - // use-credentials mode.) That behavior aligns with Gecko, with IE
|
| - // being more restrictive and not allowing fetches to such URLs.
|
| - //
|
| - // Spec reference: http://whatwg.org/c/#concept-media-load-resource
|
| - //
|
| - // FIXME: when the HTML spec switches to specifying resource
|
| - // fetches in terms of Fetch (http://fetch.spec.whatwg.org), and
|
| - // along with that potentially also specifying a setting for its
|
| - // 'authentication flag' to control how user:pass embedded in a
|
| - // media resource URL should be treated, then update the handling
|
| - // here to match.
|
| - KURL requestURL = m_currentSrc;
|
| - if (!requestURL.user().isEmpty())
|
| - requestURL.setUser(String());
|
| - if (!requestURL.pass().isEmpty())
|
| - requestURL.setPass(String());
|
| -
|
| - m_player->load(loadType(), requestURL, corsMode());
|
| -}
|
| -
|
| -void HTMLMediaElement::setPlayerPreload()
|
| -{
|
| - m_player->setPreload(m_preload);
|
| -
|
| - if (loadIsDeferred() && m_preload != MediaPlayer::None)
|
| - startDeferredLoad();
|
| -}
|
| -
|
| -bool HTMLMediaElement::loadIsDeferred() const
|
| -{
|
| - return m_deferredLoadState != NotDeferred;
|
| -}
|
| -
|
| -void HTMLMediaElement::deferLoad()
|
| -{
|
| - // This implements the "optional" step 3 from the resource fetch algorithm.
|
| - ASSERT(!m_deferredLoadTimer.isActive());
|
| - ASSERT(m_deferredLoadState == NotDeferred);
|
| - // 1. Set the networkState to NETWORK_IDLE.
|
| - // 2. Queue a task to fire a simple event named suspend at the element.
|
| - changeNetworkStateFromLoadingToIdle();
|
| - // 3. Queue a task to set the element's delaying-the-load-event
|
| - // flag to false. This stops delaying the load event.
|
| - m_deferredLoadTimer.startOneShot(0, FROM_HERE);
|
| - // 4. Wait for the task to be run.
|
| - m_deferredLoadState = WaitingForStopDelayingLoadEventTask;
|
| - // Continued in executeDeferredLoad().
|
| -}
|
| -
|
| -void HTMLMediaElement::cancelDeferredLoad()
|
| -{
|
| - m_deferredLoadTimer.stop();
|
| - m_deferredLoadState = NotDeferred;
|
| -}
|
| -
|
| -void HTMLMediaElement::executeDeferredLoad()
|
| -{
|
| - ASSERT(m_deferredLoadState >= WaitingForTrigger);
|
| -
|
| - // resource fetch algorithm step 3 - continued from deferLoad().
|
| -
|
| - // 5. Wait for an implementation-defined event (e.g. the user requesting that the media element begin playback).
|
| - // This is assumed to be whatever 'event' ended up calling this method.
|
| - cancelDeferredLoad();
|
| - // 6. Set the element's delaying-the-load-event flag back to true (this
|
| - // delays the load event again, in case it hasn't been fired yet).
|
| - setShouldDelayLoadEvent(true);
|
| - // 7. Set the networkState to NETWORK_LOADING.
|
| - m_networkState = NETWORK_LOADING;
|
| -
|
| - startProgressEventTimer();
|
| -
|
| - startPlayerLoad();
|
| -}
|
| -
|
| -void HTMLMediaElement::startDeferredLoad()
|
| -{
|
| - if (m_deferredLoadState == WaitingForTrigger) {
|
| - executeDeferredLoad();
|
| - return;
|
| - }
|
| - ASSERT(m_deferredLoadState == WaitingForStopDelayingLoadEventTask);
|
| - m_deferredLoadState = ExecuteOnStopDelayingLoadEventTask;
|
| -}
|
| -
|
| -void HTMLMediaElement::deferredLoadTimerFired(Timer<HTMLMediaElement>*)
|
| -{
|
| - setShouldDelayLoadEvent(false);
|
| -
|
| - if (m_deferredLoadState == ExecuteOnStopDelayingLoadEventTask) {
|
| - executeDeferredLoad();
|
| - return;
|
| - }
|
| - ASSERT(m_deferredLoadState == WaitingForStopDelayingLoadEventTask);
|
| - m_deferredLoadState = WaitingForTrigger;
|
| -}
|
| -
|
| -WebMediaPlayer::LoadType HTMLMediaElement::loadType() const
|
| -{
|
| - if (m_mediaSource)
|
| - return WebMediaPlayer::LoadTypeMediaSource;
|
| -
|
| - return WebMediaPlayer::LoadTypeURL;
|
| -}
|
| -
|
| -bool HTMLMediaElement::isSafeToLoadURL(const KURL& url, InvalidURLAction actionIfInvalid)
|
| -{
|
| - if (!url.isValid()) {
|
| - WTF_LOG(Media, "HTMLMediaElement::isSafeToLoadURL(%s) -> FALSE because url is invalid", urlForLoggingMedia(url).utf8().data());
|
| - return false;
|
| - }
|
| -
|
| - return true;
|
| -}
|
| -
|
| -void HTMLMediaElement::startProgressEventTimer()
|
| -{
|
| - if (m_progressEventTimer.isActive())
|
| - return;
|
| -
|
| - m_previousProgressTime = WTF::currentTime();
|
| - // 350ms is not magic, it is in the spec!
|
| - m_progressEventTimer.startRepeating(0.350, FROM_HERE);
|
| -}
|
| -
|
| -void HTMLMediaElement::waitForSourceChange()
|
| -{
|
| - WTF_LOG(Media, "HTMLMediaElement::waitForSourceChange");
|
| -
|
| - stopPeriodicTimers();
|
| - m_loadState = WaitingForSource;
|
| -
|
| - // 6.17 - Waiting: Set the element's networkState attribute to the NETWORK_NO_SOURCE value
|
| - m_networkState = NETWORK_NO_SOURCE;
|
| -
|
| - // 6.18 - Set the element's delaying-the-load-event flag to false. This stops delaying the load event.
|
| - setShouldDelayLoadEvent(false);
|
| -
|
| - updateDisplayState();
|
| -
|
| - if (renderer())
|
| - renderer()->updateFromElement();
|
| -}
|
| -
|
| -void HTMLMediaElement::noneSupported()
|
| -{
|
| - WTF_LOG(Media, "HTMLMediaElement::noneSupported");
|
| -
|
| - stopPeriodicTimers();
|
| - m_loadState = WaitingForSource;
|
| - m_currentSourceNode = nullptr;
|
| -
|
| - // 4.8.10.5
|
| - // 6 - Reaching this step indicates that the media resource failed to load or that the given
|
| - // URL could not be resolved. In one atomic operation, run the following steps:
|
| -
|
| - // 6.1 - Set the error attribute to a new MediaError object whose code attribute is set to
|
| - // MEDIA_ERR_SRC_NOT_SUPPORTED.
|
| - m_error = MediaError::create(MediaError::MEDIA_ERR_SRC_NOT_SUPPORTED);
|
| -
|
| - // 6.2 - Forget the media element's media-resource-specific text tracks.
|
| - // FIXME(sky): We have no tracks.
|
| -
|
| - // 6.3 - Set the element's networkState attribute to the NETWORK_NO_SOURCE value.
|
| - m_networkState = NETWORK_NO_SOURCE;
|
| -
|
| - // 7 - Queue a task to fire a simple event named error at the media element.
|
| - scheduleEvent(EventTypeNames::error);
|
| -
|
| - closeMediaSource();
|
| -
|
| - // 8 - Set the element's delaying-the-load-event flag to false. This stops delaying the load event.
|
| - setShouldDelayLoadEvent(false);
|
| -
|
| - // 9 - Abort these steps. Until the load() method is invoked or the src attribute is changed,
|
| - // the element won't attempt to load another resource.
|
| -
|
| - updateDisplayState();
|
| -
|
| - if (renderer())
|
| - renderer()->updateFromElement();
|
| -}
|
| -
|
| -void HTMLMediaElement::mediaEngineError(PassRefPtr<MediaError> err)
|
| -{
|
| - ASSERT(m_readyState >= HAVE_METADATA);
|
| - WTF_LOG(Media, "HTMLMediaElement::mediaEngineError(%d)", static_cast<int>(err->code()));
|
| -
|
| - // 1 - The user agent should cancel the fetching process.
|
| - stopPeriodicTimers();
|
| - m_loadState = WaitingForSource;
|
| -
|
| - // 2 - Set the error attribute to a new MediaError object whose code attribute is
|
| - // set to MEDIA_ERR_NETWORK/MEDIA_ERR_DECODE.
|
| - m_error = err;
|
| -
|
| - // 3 - Queue a task to fire a simple event named error at the media element.
|
| - scheduleEvent(EventTypeNames::error);
|
| -
|
| - // 4 - Set the element's networkState attribute to the NETWORK_IDLE value.
|
| - m_networkState = NETWORK_IDLE;
|
| -
|
| - // 5 - Set the element's delaying-the-load-event flag to false. This stops delaying the load event.
|
| - setShouldDelayLoadEvent(false);
|
| -
|
| - // 6 - Abort the overall resource selection algorithm.
|
| - m_currentSourceNode = nullptr;
|
| -}
|
| -
|
| -void HTMLMediaElement::cancelPendingEventsAndCallbacks()
|
| -{
|
| - WTF_LOG(Media, "HTMLMediaElement::cancelPendingEventsAndCallbacks");
|
| - m_asyncEventQueue->cancelAllEvents();
|
| -
|
| - for (HTMLSourceElement* source = Traversal<HTMLSourceElement>::firstChild(*this); source; source = Traversal<HTMLSourceElement>::nextSibling(*source))
|
| - source->cancelPendingErrorEvent();
|
| -}
|
| -
|
| -void HTMLMediaElement::mediaPlayerNetworkStateChanged()
|
| -{
|
| - setNetworkState(webMediaPlayer()->networkState());
|
| -}
|
| -
|
| -void HTMLMediaElement::mediaLoadingFailed(WebMediaPlayer::NetworkState error)
|
| -{
|
| - stopPeriodicTimers();
|
| -
|
| - // If we failed while trying to load a <source> element, the movie was never parsed, and there are more
|
| - // <source> children, schedule the next one
|
| - if (m_readyState < HAVE_METADATA && m_loadState == LoadingFromSourceElement) {
|
| -
|
| - // resource selection algorithm
|
| - // Step 9.Otherwise.9 - Failed with elements: Queue a task, using the DOM manipulation task source, to fire a simple event named error at the candidate element.
|
| - if (m_currentSourceNode)
|
| - m_currentSourceNode->scheduleErrorEvent();
|
| - else
|
| - WTF_LOG(Media, "HTMLMediaElement::setNetworkState - error event not sent, <source> was removed");
|
| -
|
| - // 9.Otherwise.10 - Asynchronously await a stable state. The synchronous section consists of all the remaining steps of this algorithm until the algorithm says the synchronous section has ended.
|
| -
|
| - // 9.Otherwise.11 - Forget the media element's media-resource-specific tracks.
|
| - // FIXME(sky): We have no tracks.
|
| -
|
| - if (havePotentialSourceChild()) {
|
| - WTF_LOG(Media, "HTMLMediaElement::setNetworkState - scheduling next <source>");
|
| - scheduleNextSourceChild();
|
| - } else {
|
| - WTF_LOG(Media, "HTMLMediaElement::setNetworkState - no more <source> elements, waiting");
|
| - waitForSourceChange();
|
| - }
|
| -
|
| - return;
|
| - }
|
| -
|
| - if (error == WebMediaPlayer::NetworkStateNetworkError && m_readyState >= HAVE_METADATA)
|
| - mediaEngineError(MediaError::create(MediaError::MEDIA_ERR_NETWORK));
|
| - else if (error == WebMediaPlayer::NetworkStateDecodeError)
|
| - mediaEngineError(MediaError::create(MediaError::MEDIA_ERR_DECODE));
|
| - else if ((error == WebMediaPlayer::NetworkStateFormatError
|
| - || error == WebMediaPlayer::NetworkStateNetworkError)
|
| - && m_loadState == LoadingFromSrcAttr)
|
| - noneSupported();
|
| -
|
| - updateDisplayState();
|
| -}
|
| -
|
| -void HTMLMediaElement::setNetworkState(WebMediaPlayer::NetworkState state)
|
| -{
|
| - WTF_LOG(Media, "HTMLMediaElement::setNetworkState(%d) - current state is %d", static_cast<int>(state), static_cast<int>(m_networkState));
|
| -
|
| - if (state == WebMediaPlayer::NetworkStateEmpty) {
|
| - // Just update the cached state and leave, we can't do anything.
|
| - m_networkState = NETWORK_EMPTY;
|
| - return;
|
| - }
|
| -
|
| - if (state == WebMediaPlayer::NetworkStateFormatError
|
| - || state == WebMediaPlayer::NetworkStateNetworkError
|
| - || state == WebMediaPlayer::NetworkStateDecodeError) {
|
| - mediaLoadingFailed(state);
|
| - return;
|
| - }
|
| -
|
| - if (state == WebMediaPlayer::NetworkStateIdle) {
|
| - if (m_networkState > NETWORK_IDLE) {
|
| - changeNetworkStateFromLoadingToIdle();
|
| - setShouldDelayLoadEvent(false);
|
| - } else {
|
| - m_networkState = NETWORK_IDLE;
|
| - }
|
| - }
|
| -
|
| - if (state == WebMediaPlayer::NetworkStateLoading) {
|
| - if (m_networkState < NETWORK_LOADING || m_networkState == NETWORK_NO_SOURCE)
|
| - startProgressEventTimer();
|
| - m_networkState = NETWORK_LOADING;
|
| - }
|
| -
|
| - if (state == WebMediaPlayer::NetworkStateLoaded) {
|
| - if (m_networkState != NETWORK_IDLE)
|
| - changeNetworkStateFromLoadingToIdle();
|
| - m_completelyLoaded = true;
|
| - }
|
| -}
|
| -
|
| -void HTMLMediaElement::changeNetworkStateFromLoadingToIdle()
|
| -{
|
| - ASSERT(m_player);
|
| - m_progressEventTimer.stop();
|
| -
|
| - // Schedule one last progress event so we guarantee that at least one is fired
|
| - // for files that load very quickly.
|
| - if (webMediaPlayer() && webMediaPlayer()->didLoadingProgress())
|
| - scheduleEvent(EventTypeNames::progress);
|
| - scheduleEvent(EventTypeNames::suspend);
|
| - m_networkState = NETWORK_IDLE;
|
| -}
|
| -
|
| -void HTMLMediaElement::mediaPlayerReadyStateChanged()
|
| -{
|
| - setReadyState(static_cast<ReadyState>(webMediaPlayer()->readyState()));
|
| -}
|
| -
|
| -void HTMLMediaElement::setReadyState(ReadyState state)
|
| -{
|
| - WTF_LOG(Media, "HTMLMediaElement::setReadyState(%d) - current state is %d,", static_cast<int>(state), static_cast<int>(m_readyState));
|
| -
|
| - // Set "wasPotentiallyPlaying" BEFORE updating m_readyState, potentiallyPlaying() uses it
|
| - bool wasPotentiallyPlaying = potentiallyPlaying();
|
| -
|
| - ReadyState oldState = m_readyState;
|
| - ReadyState newState = state;
|
| -
|
| - if (newState == oldState)
|
| - return;
|
| -
|
| - m_readyState = newState;
|
| -
|
| - if (oldState > m_readyStateMaximum)
|
| - m_readyStateMaximum = oldState;
|
| -
|
| - if (m_networkState == NETWORK_EMPTY)
|
| - return;
|
| -
|
| - if (m_seeking) {
|
| - // 4.8.10.9, step 9 note: If the media element was potentially playing immediately before
|
| - // it started seeking, but seeking caused its readyState attribute to change to a value
|
| - // lower than HAVE_FUTURE_DATA, then a waiting will be fired at the element.
|
| - if (wasPotentiallyPlaying && m_readyState < HAVE_FUTURE_DATA)
|
| - scheduleEvent(EventTypeNames::waiting);
|
| -
|
| - // 4.8.10.9 steps 12-14
|
| - if (m_readyState >= HAVE_CURRENT_DATA)
|
| - finishSeek();
|
| - } else {
|
| - if (wasPotentiallyPlaying && m_readyState < HAVE_FUTURE_DATA) {
|
| - // 4.8.10.8
|
| - scheduleTimeupdateEvent(false);
|
| - scheduleEvent(EventTypeNames::waiting);
|
| - }
|
| - }
|
| -
|
| - if (m_readyState >= HAVE_METADATA && oldState < HAVE_METADATA) {
|
| - prepareMediaFragmentURI();
|
| -
|
| - m_duration = duration();
|
| - scheduleEvent(EventTypeNames::durationchange);
|
| - scheduleEvent(EventTypeNames::loadedmetadata);
|
| - if (renderer())
|
| - renderer()->updateFromElement();
|
| - }
|
| -
|
| - bool shouldUpdateDisplayState = false;
|
| -
|
| - if (m_readyState >= HAVE_CURRENT_DATA && oldState < HAVE_CURRENT_DATA && !m_haveFiredLoadedData) {
|
| - m_haveFiredLoadedData = true;
|
| - shouldUpdateDisplayState = true;
|
| - scheduleEvent(EventTypeNames::loadeddata);
|
| - setShouldDelayLoadEvent(false);
|
| - applyMediaFragmentURI();
|
| - }
|
| -
|
| - bool isPotentiallyPlaying = potentiallyPlaying();
|
| - if (m_readyState == HAVE_FUTURE_DATA && oldState <= HAVE_CURRENT_DATA) {
|
| - scheduleEvent(EventTypeNames::canplay);
|
| - if (isPotentiallyPlaying)
|
| - scheduleEvent(EventTypeNames::playing);
|
| - shouldUpdateDisplayState = true;
|
| - }
|
| -
|
| - if (m_readyState == HAVE_ENOUGH_DATA && oldState < HAVE_ENOUGH_DATA) {
|
| - if (oldState <= HAVE_CURRENT_DATA) {
|
| - scheduleEvent(EventTypeNames::canplay);
|
| - if (isPotentiallyPlaying)
|
| - scheduleEvent(EventTypeNames::playing);
|
| - }
|
| -
|
| - if (m_autoplaying && m_paused && autoplay() && !m_userGestureRequiredForPlay) {
|
| - m_paused = false;
|
| - invalidateCachedTime();
|
| - scheduleEvent(EventTypeNames::play);
|
| - scheduleEvent(EventTypeNames::playing);
|
| - }
|
| -
|
| - scheduleEvent(EventTypeNames::canplaythrough);
|
| -
|
| - shouldUpdateDisplayState = true;
|
| - }
|
| -
|
| - if (shouldUpdateDisplayState)
|
| - updateDisplayState();
|
| -
|
| - updatePlayState();
|
| -}
|
| -
|
| -void HTMLMediaElement::progressEventTimerFired(Timer<HTMLMediaElement>*)
|
| -{
|
| - ASSERT(m_player);
|
| - if (m_networkState != NETWORK_LOADING)
|
| - return;
|
| -
|
| - double time = WTF::currentTime();
|
| - double timedelta = time - m_previousProgressTime;
|
| -
|
| - if (webMediaPlayer() && webMediaPlayer()->didLoadingProgress()) {
|
| - scheduleEvent(EventTypeNames::progress);
|
| - m_previousProgressTime = time;
|
| - m_sentStalledEvent = false;
|
| - if (renderer())
|
| - renderer()->updateFromElement();
|
| - } else if (timedelta > 3.0 && !m_sentStalledEvent) {
|
| - scheduleEvent(EventTypeNames::stalled);
|
| - m_sentStalledEvent = true;
|
| - setShouldDelayLoadEvent(false);
|
| - }
|
| -}
|
| -
|
| -void HTMLMediaElement::addPlayedRange(double start, double end)
|
| -{
|
| - WTF_LOG(Media, "HTMLMediaElement::addPlayedRange(%f, %f)", start, end);
|
| - if (!m_playedTimeRanges)
|
| - m_playedTimeRanges = TimeRanges::create();
|
| - m_playedTimeRanges->add(start, end);
|
| -}
|
| -
|
| -bool HTMLMediaElement::supportsSave() const
|
| -{
|
| - return webMediaPlayer() && webMediaPlayer()->supportsSave();
|
| -}
|
| -
|
| -void HTMLMediaElement::prepareToPlay()
|
| -{
|
| - WTF_LOG(Media, "HTMLMediaElement::prepareToPlay(%p)", this);
|
| - if (m_havePreparedToPlay)
|
| - return;
|
| - m_havePreparedToPlay = true;
|
| -
|
| - if (loadIsDeferred())
|
| - startDeferredLoad();
|
| -}
|
| -
|
| -void HTMLMediaElement::seek(double time, ExceptionState& exceptionState)
|
| -{
|
| - WTF_LOG(Media, "HTMLMediaElement::seek(%f)", time);
|
| -
|
| - // 4.8.10.9 Seeking
|
| -
|
| - // 1 - If the media element's readyState is HAVE_NOTHING, then raise an InvalidStateError exception.
|
| - if (m_readyState == HAVE_NOTHING) {
|
| - exceptionState.throwDOMException(InvalidStateError, "The element's readyState is HAVE_NOTHING.");
|
| - return;
|
| - }
|
| -
|
| - // If the media engine has been told to postpone loading data, let it go ahead now.
|
| - if (m_preload < MediaPlayer::Auto && m_readyState < HAVE_FUTURE_DATA)
|
| - prepareToPlay();
|
| -
|
| - // Get the current time before setting m_seeking, m_lastSeekTime is returned once it is set.
|
| - refreshCachedTime();
|
| - double now = currentTime();
|
| -
|
| - // 2 - If the element's seeking IDL attribute is true, then another instance of this algorithm is
|
| - // already running. Abort that other instance of the algorithm without waiting for the step that
|
| - // it is running to complete.
|
| - // Nothing specific to be done here.
|
| -
|
| - // 3 - Set the seeking IDL attribute to true.
|
| - // The flag will be cleared when the engine tells us the time has actually changed.
|
| - bool previousSeekStillPending = m_seeking;
|
| - m_seeking = true;
|
| -
|
| - // 5 - If the new playback position is later than the end of the media resource, then let it be the end
|
| - // of the media resource instead.
|
| - time = std::min(time, duration());
|
| -
|
| - // 6 - If the new playback position is less than the earliest possible position, let it be that position instead.
|
| - time = std::max(time, 0.0);
|
| -
|
| - // Ask the media engine for the time value in the movie's time scale before comparing with current time. This
|
| - // is necessary because if the seek time is not equal to currentTime but the delta is less than the movie's
|
| - // time scale, we will ask the media engine to "seek" to the current movie time, which may be a noop and
|
| - // not generate a timechanged callback. This means m_seeking will never be cleared and we will never
|
| - // fire a 'seeked' event.
|
| - double mediaTime = webMediaPlayer()->mediaTimeForTimeValue(time);
|
| - if (time != mediaTime) {
|
| - WTF_LOG(Media, "HTMLMediaElement::seek(%f) - media timeline equivalent is %f", time, mediaTime);
|
| - time = mediaTime;
|
| - }
|
| -
|
| - // 7 - If the (possibly now changed) new playback position is not in one of the ranges given in the
|
| - // seekable attribute, then let it be the position in one of the ranges given in the seekable attribute
|
| - // that is the nearest to the new playback position. ... If there are no ranges given in the seekable
|
| - // attribute then set the seeking IDL attribute to false and abort these steps.
|
| - RefPtr<TimeRanges> seekableRanges = seekable();
|
| -
|
| - // Short circuit seeking to the current time by just firing the events if no seek is required.
|
| - // Don't skip calling the media engine if we are in poster mode because a seek should always
|
| - // cancel poster display.
|
| - bool noSeekRequired = !seekableRanges->length() || (time == now && displayMode() != Poster);
|
| -
|
| - if (noSeekRequired) {
|
| - if (time == now) {
|
| - scheduleEvent(EventTypeNames::seeking);
|
| - if (previousSeekStillPending)
|
| - return;
|
| - // FIXME: There must be a stable state before timeupdate+seeked are dispatched and seeking
|
| - // is reset to false. See http://crbug.com/266631
|
| - scheduleTimeupdateEvent(false);
|
| - scheduleEvent(EventTypeNames::seeked);
|
| - }
|
| - m_seeking = false;
|
| - return;
|
| - }
|
| - time = seekableRanges->nearest(time);
|
| -
|
| - if (m_playing) {
|
| - if (m_lastSeekTime < now)
|
| - addPlayedRange(m_lastSeekTime, now);
|
| - }
|
| - m_lastSeekTime = time;
|
| - m_sentEndEvent = false;
|
| -
|
| - // 8 - Queue a task to fire a simple event named seeking at the element.
|
| - scheduleEvent(EventTypeNames::seeking);
|
| -
|
| - // 9 - Set the current playback position to the given new playback position
|
| - webMediaPlayer()->seek(time);
|
| -
|
| - // 10-14 are handled, if necessary, when the engine signals a readystate change or otherwise
|
| - // satisfies seek completion and signals a time change.
|
| -}
|
| -
|
| -void HTMLMediaElement::finishSeek()
|
| -{
|
| - WTF_LOG(Media, "HTMLMediaElement::finishSeek");
|
| -
|
| - // 4.8.10.9 Seeking completion
|
| - // 12 - Set the seeking IDL attribute to false.
|
| - m_seeking = false;
|
| -
|
| - // 13 - Queue a task to fire a simple event named timeupdate at the element.
|
| - scheduleTimeupdateEvent(false);
|
| -
|
| - // 14 - Queue a task to fire a simple event named seeked at the element.
|
| - scheduleEvent(EventTypeNames::seeked);
|
| -
|
| - setDisplayMode(Video);
|
| -}
|
| -
|
| -HTMLMediaElement::ReadyState HTMLMediaElement::readyState() const
|
| -{
|
| - return m_readyState;
|
| -}
|
| -
|
| -bool HTMLMediaElement::hasAudio() const
|
| -{
|
| - return webMediaPlayer() && webMediaPlayer()->hasAudio();
|
| -}
|
| -
|
| -bool HTMLMediaElement::seeking() const
|
| -{
|
| - return m_seeking;
|
| -}
|
| -
|
| -void HTMLMediaElement::refreshCachedTime() const
|
| -{
|
| - if (!webMediaPlayer() || m_readyState < HAVE_METADATA)
|
| - return;
|
| -
|
| - m_cachedTime = webMediaPlayer()->currentTime();
|
| -}
|
| -
|
| -void HTMLMediaElement::invalidateCachedTime()
|
| -{
|
| - WTF_LOG(Media, "HTMLMediaElement::invalidateCachedTime");
|
| - m_cachedTime = MediaPlayer::invalidTime();
|
| -}
|
| -
|
| -// playback state
|
| -double HTMLMediaElement::currentTime() const
|
| -{
|
| - if (m_readyState == HAVE_NOTHING)
|
| - return 0;
|
| -
|
| - if (m_seeking) {
|
| - WTF_LOG(Media, "HTMLMediaElement::currentTime - seeking, returning %f", m_lastSeekTime);
|
| - return m_lastSeekTime;
|
| - }
|
| -
|
| - if (m_cachedTime != MediaPlayer::invalidTime() && m_paused) {
|
| -#if LOG_CACHED_TIME_WARNINGS
|
| - static const double minCachedDeltaForWarning = 0.01;
|
| - double delta = m_cachedTime - webMediaPlayer()->currentTime();
|
| - if (delta > minCachedDeltaForWarning)
|
| - WTF_LOG(Media, "HTMLMediaElement::currentTime - WARNING, cached time is %f seconds off of media time when paused", delta);
|
| -#endif
|
| - return m_cachedTime;
|
| - }
|
| -
|
| - refreshCachedTime();
|
| -
|
| - return m_cachedTime;
|
| -}
|
| -
|
| -void HTMLMediaElement::setCurrentTime(double time, ExceptionState& exceptionState)
|
| -{
|
| - seek(time, exceptionState);
|
| -}
|
| -
|
| -double HTMLMediaElement::duration() const
|
| -{
|
| - // FIXME: remove m_player check once we figure out how m_player is going
|
| - // out of sync with readystate. m_player is cleared but readystate is not set
|
| - // to HAVE_NOTHING
|
| - if (!m_player || m_readyState < HAVE_METADATA)
|
| - return std::numeric_limits<double>::quiet_NaN();
|
| -
|
| - // FIXME: Refactor so m_duration is kept current (in both MSE and
|
| - // non-MSE cases) once we have transitioned from HAVE_NOTHING ->
|
| - // HAVE_METADATA. Currently, m_duration may be out of date for at least MSE
|
| - // case because MediaSource and SourceBuffer do not notify the element
|
| - // directly upon duration changes caused by endOfStream, remove, or append
|
| - // operations; rather the notification is triggered by the WebMediaPlayer
|
| - // implementation observing that the underlying engine has updated duration
|
| - // and notifying the element to consult its MediaSource for current
|
| - // duration. See http://crbug.com/266644
|
| -
|
| - if (m_mediaSource)
|
| - return m_mediaSource->duration();
|
| -
|
| - return webMediaPlayer()->duration();
|
| -}
|
| -
|
| -bool HTMLMediaElement::paused() const
|
| -{
|
| - return m_paused;
|
| -}
|
| -
|
| -double HTMLMediaElement::defaultPlaybackRate() const
|
| -{
|
| - return m_defaultPlaybackRate;
|
| -}
|
| -
|
| -void HTMLMediaElement::setDefaultPlaybackRate(double rate)
|
| -{
|
| - if (m_defaultPlaybackRate == rate)
|
| - return;
|
| -
|
| - m_defaultPlaybackRate = rate;
|
| - scheduleEvent(EventTypeNames::ratechange);
|
| -}
|
| -
|
| -double HTMLMediaElement::playbackRate() const
|
| -{
|
| - return m_playbackRate;
|
| -}
|
| -
|
| -void HTMLMediaElement::setPlaybackRate(double rate)
|
| -{
|
| - WTF_LOG(Media, "HTMLMediaElement::setPlaybackRate(%f)", rate);
|
| -
|
| - if (m_playbackRate != rate) {
|
| - m_playbackRate = rate;
|
| - invalidateCachedTime();
|
| - scheduleEvent(EventTypeNames::ratechange);
|
| - }
|
| -
|
| - updatePlaybackRate();
|
| -}
|
| -
|
| -double HTMLMediaElement::effectivePlaybackRate() const
|
| -{
|
| - return m_playbackRate;
|
| -}
|
| -
|
| -HTMLMediaElement::DirectionOfPlayback HTMLMediaElement::directionOfPlayback() const
|
| -{
|
| - return m_playbackRate >= 0 ? Forward : Backward;
|
| -}
|
| -
|
| -void HTMLMediaElement::updatePlaybackRate()
|
| -{
|
| - double effectiveRate = effectivePlaybackRate();
|
| - if (m_player && potentiallyPlaying())
|
| - webMediaPlayer()->setRate(effectiveRate);
|
| -}
|
| -
|
| -bool HTMLMediaElement::ended() const
|
| -{
|
| - // 4.8.10.8 Playing the media resource
|
| - // The ended attribute must return true if the media element has ended
|
| - // playback and the direction of playback is forwards, and false otherwise.
|
| - return endedPlayback() && directionOfPlayback() == Forward;
|
| -}
|
| -
|
| -bool HTMLMediaElement::autoplay() const
|
| -{
|
| - return hasAttribute(HTMLNames::autoplayAttr);
|
| -}
|
| -
|
| -String HTMLMediaElement::preload() const
|
| -{
|
| - switch (m_preload) {
|
| - case MediaPlayer::None:
|
| - return "none";
|
| - break;
|
| - case MediaPlayer::MetaData:
|
| - return "metadata";
|
| - break;
|
| - case MediaPlayer::Auto:
|
| - return "auto";
|
| - break;
|
| - }
|
| -
|
| - ASSERT_NOT_REACHED();
|
| - return String();
|
| -}
|
| -
|
| -void HTMLMediaElement::setPreload(const AtomicString& preload)
|
| -{
|
| - WTF_LOG(Media, "HTMLMediaElement::setPreload(%s)", preload.utf8().data());
|
| - setAttribute(HTMLNames::preloadAttr, preload);
|
| -}
|
| -
|
| -void HTMLMediaElement::play()
|
| -{
|
| - WTF_LOG(Media, "HTMLMediaElement::play()");
|
| -
|
| - if (m_userGestureRequiredForPlay && !UserGestureIndicator::processingUserGesture())
|
| - return;
|
| - if (UserGestureIndicator::processingUserGesture())
|
| - m_userGestureRequiredForPlay = false;
|
| -
|
| - playInternal();
|
| -}
|
| -
|
| -void HTMLMediaElement::playInternal()
|
| -{
|
| - WTF_LOG(Media, "HTMLMediaElement::playInternal");
|
| -
|
| - // 4.8.10.9. Playing the media resource
|
| - if (!m_player || m_networkState == NETWORK_EMPTY)
|
| - scheduleDelayedAction(LoadMediaResource);
|
| -
|
| - if (endedPlayback())
|
| - seek(0, IGNORE_EXCEPTION);
|
| -
|
| - if (m_paused) {
|
| - m_paused = false;
|
| - invalidateCachedTime();
|
| - scheduleEvent(EventTypeNames::play);
|
| -
|
| - if (m_readyState <= HAVE_CURRENT_DATA)
|
| - scheduleEvent(EventTypeNames::waiting);
|
| - else if (m_readyState >= HAVE_FUTURE_DATA)
|
| - scheduleEvent(EventTypeNames::playing);
|
| - }
|
| - m_autoplaying = false;
|
| -
|
| - updatePlayState();
|
| -}
|
| -
|
| -void HTMLMediaElement::pause()
|
| -{
|
| - WTF_LOG(Media, "HTMLMediaElement::pause()");
|
| -
|
| - if (!m_player || m_networkState == NETWORK_EMPTY)
|
| - scheduleDelayedAction(LoadMediaResource);
|
| -
|
| - m_autoplaying = false;
|
| -
|
| - if (!m_paused) {
|
| - m_paused = true;
|
| - scheduleTimeupdateEvent(false);
|
| - scheduleEvent(EventTypeNames::pause);
|
| - }
|
| -
|
| - updatePlayState();
|
| -}
|
| -
|
| -void HTMLMediaElement::closeMediaSource()
|
| -{
|
| - if (!m_mediaSource)
|
| - return;
|
| -
|
| - m_mediaSource->close();
|
| - m_mediaSource = nullptr;
|
| -}
|
| -
|
| -bool HTMLMediaElement::loop() const
|
| -{
|
| - return hasAttribute(HTMLNames::loopAttr);
|
| -}
|
| -
|
| -void HTMLMediaElement::setLoop(bool b)
|
| -{
|
| - WTF_LOG(Media, "HTMLMediaElement::setLoop(%s)", boolString(b));
|
| - setBooleanAttribute(HTMLNames::loopAttr, b);
|
| -}
|
| -
|
| -double HTMLMediaElement::volume() const
|
| -{
|
| - return m_volume;
|
| -}
|
| -
|
| -void HTMLMediaElement::setVolume(double vol, ExceptionState& exceptionState)
|
| -{
|
| - WTF_LOG(Media, "HTMLMediaElement::setVolume(%f)", vol);
|
| -
|
| - if (m_volume == vol)
|
| - return;
|
| -
|
| - if (vol < 0.0f || vol > 1.0f) {
|
| - exceptionState.throwDOMException(IndexSizeError, ExceptionMessages::indexOutsideRange("volume", vol, 0.0, ExceptionMessages::InclusiveBound, 1.0, ExceptionMessages::InclusiveBound));
|
| - return;
|
| - }
|
| -
|
| - m_volume = vol;
|
| - updateVolume();
|
| - scheduleEvent(EventTypeNames::volumechange);
|
| -}
|
| -
|
| -bool HTMLMediaElement::muted() const
|
| -{
|
| - return m_muted;
|
| -}
|
| -
|
| -void HTMLMediaElement::setMuted(bool muted)
|
| -{
|
| - WTF_LOG(Media, "HTMLMediaElement::setMuted(%s)", boolString(muted));
|
| -
|
| - if (m_muted == muted)
|
| - return;
|
| -
|
| - m_muted = muted;
|
| -
|
| - updateVolume();
|
| -
|
| - scheduleEvent(EventTypeNames::volumechange);
|
| -}
|
| -
|
| -void HTMLMediaElement::updateVolume()
|
| -{
|
| - if (webMediaPlayer())
|
| - webMediaPlayer()->setVolume(effectiveMediaVolume());
|
| -}
|
| -
|
| -double HTMLMediaElement::effectiveMediaVolume() const
|
| -{
|
| - if (m_muted)
|
| - return 0;
|
| -
|
| - return m_volume;
|
| -}
|
| -
|
| -// The spec says to fire periodic timeupdate events (those sent while playing) every
|
| -// "15 to 250ms", we choose the slowest frequency
|
| -static const double maxTimeupdateEventFrequency = 0.25;
|
| -
|
| -void HTMLMediaElement::startPlaybackProgressTimer()
|
| -{
|
| - if (m_playbackProgressTimer.isActive())
|
| - return;
|
| -
|
| - m_previousProgressTime = WTF::currentTime();
|
| - m_playbackProgressTimer.startRepeating(maxTimeupdateEventFrequency, FROM_HERE);
|
| -}
|
| -
|
| -void HTMLMediaElement::playbackProgressTimerFired(Timer<HTMLMediaElement>*)
|
| -{
|
| - ASSERT(m_player);
|
| -
|
| - if (m_fragmentEndTime != MediaPlayer::invalidTime() && currentTime() >= m_fragmentEndTime && directionOfPlayback() == Forward) {
|
| - m_fragmentEndTime = MediaPlayer::invalidTime();
|
| - if (!m_paused) {
|
| - UseCounter::count(document(), UseCounter::HTMLMediaElementPauseAtFragmentEnd);
|
| - // changes paused to true and fires a simple event named pause at the media element.
|
| - pause();
|
| - }
|
| - }
|
| -
|
| - if (!m_seeking)
|
| - scheduleTimeupdateEvent(true);
|
| -}
|
| -
|
| -void HTMLMediaElement::scheduleTimeupdateEvent(bool periodicEvent)
|
| -{
|
| - double now = WTF::currentTime();
|
| - double timedelta = now - m_lastTimeUpdateEventWallTime;
|
| -
|
| - // throttle the periodic events
|
| - if (periodicEvent && timedelta < maxTimeupdateEventFrequency)
|
| - return;
|
| -
|
| - // Some media engines make multiple "time changed" callbacks at the same time, but we only want one
|
| - // event at a given time so filter here
|
| - double movieTime = currentTime();
|
| - if (movieTime != m_lastTimeUpdateEventMovieTime) {
|
| - scheduleEvent(EventTypeNames::timeupdate);
|
| - m_lastTimeUpdateEventWallTime = now;
|
| - m_lastTimeUpdateEventMovieTime = movieTime;
|
| - }
|
| -}
|
| -
|
| -bool HTMLMediaElement::togglePlayStateWillPlay() const
|
| -{
|
| - return paused();
|
| -}
|
| -
|
| -void HTMLMediaElement::togglePlayState()
|
| -{
|
| - if (paused())
|
| - play();
|
| - else
|
| - pause();
|
| -}
|
| -
|
| -bool HTMLMediaElement::havePotentialSourceChild()
|
| -{
|
| - // Stash the current <source> node and next nodes so we can restore them after checking
|
| - // to see there is another potential.
|
| - RefPtr<HTMLSourceElement> currentSourceNode = m_currentSourceNode;
|
| - RefPtr<Node> nextNode = m_nextChildNodeToConsider;
|
| -
|
| - KURL nextURL = selectNextSourceChild(0, 0, DoNothing);
|
| -
|
| - m_currentSourceNode = currentSourceNode;
|
| - m_nextChildNodeToConsider = nextNode;
|
| -
|
| - return nextURL.isValid();
|
| -}
|
| -
|
| -KURL HTMLMediaElement::selectNextSourceChild(ContentType* contentType, String* keySystem, InvalidURLAction actionIfInvalid)
|
| -{
|
| -#if !LOG_DISABLED
|
| - // Don't log if this was just called to find out if there are any valid <source> elements.
|
| - bool shouldLog = actionIfInvalid != DoNothing;
|
| - if (shouldLog)
|
| - WTF_LOG(Media, "HTMLMediaElement::selectNextSourceChild");
|
| -#endif
|
| -
|
| - if (!m_nextChildNodeToConsider) {
|
| -#if !LOG_DISABLED
|
| - if (shouldLog)
|
| - WTF_LOG(Media, "HTMLMediaElement::selectNextSourceChild -> 0x0000, \"\"");
|
| -#endif
|
| - return KURL();
|
| - }
|
| -
|
| - KURL mediaURL;
|
| - Node* node;
|
| - HTMLSourceElement* source = 0;
|
| - String type;
|
| - String system;
|
| - bool lookingForStartNode = m_nextChildNodeToConsider;
|
| - bool canUseSourceElement = false;
|
| -
|
| - NodeVector potentialSourceNodes;
|
| - getChildNodes(*this, potentialSourceNodes);
|
| -
|
| - for (unsigned i = 0; !canUseSourceElement && i < potentialSourceNodes.size(); ++i) {
|
| - node = potentialSourceNodes[i].get();
|
| - if (lookingForStartNode && m_nextChildNodeToConsider != node)
|
| - continue;
|
| - lookingForStartNode = false;
|
| -
|
| - if (!isHTMLSourceElement(*node))
|
| - continue;
|
| - if (node->parentNode() != this)
|
| - continue;
|
| -
|
| - source = toHTMLSourceElement(node);
|
| -
|
| - // If candidate does not have a src attribute, or if its src attribute's value is the empty string ... jump down to the failed step below
|
| - mediaURL = source->getNonEmptyURLAttribute(HTMLNames::srcAttr);
|
| -#if !LOG_DISABLED
|
| - if (shouldLog)
|
| - WTF_LOG(Media, "HTMLMediaElement::selectNextSourceChild - 'src' is %s", urlForLoggingMedia(mediaURL).utf8().data());
|
| -#endif
|
| - if (mediaURL.isEmpty())
|
| - goto check_again;
|
| -
|
| - type = source->type();
|
| - // FIXME(82965): Add support for keySystem in <source> and set system from source.
|
| - if (type.isEmpty() && mediaURL.protocolIsData())
|
| - type = mimeTypeFromDataURL(mediaURL);
|
| - if (!type.isEmpty() || !system.isEmpty()) {
|
| -#if !LOG_DISABLED
|
| - if (shouldLog)
|
| - WTF_LOG(Media, "HTMLMediaElement::selectNextSourceChild - 'type' is '%s' - key system is '%s'", type.utf8().data(), system.utf8().data());
|
| -#endif
|
| - if (!supportsType(ContentType(type), system))
|
| - goto check_again;
|
| - }
|
| -
|
| - // Is it safe to load this url?
|
| - if (!isSafeToLoadURL(mediaURL, actionIfInvalid))
|
| - goto check_again;
|
| -
|
| - // Making it this far means the <source> looks reasonable.
|
| - canUseSourceElement = true;
|
| -
|
| -check_again:
|
| - if (!canUseSourceElement && actionIfInvalid == Complain && source)
|
| - source->scheduleErrorEvent();
|
| - }
|
| -
|
| - if (canUseSourceElement) {
|
| - if (contentType)
|
| - *contentType = ContentType(type);
|
| - if (keySystem)
|
| - *keySystem = system;
|
| - m_currentSourceNode = source;
|
| - m_nextChildNodeToConsider = source->nextSibling();
|
| - } else {
|
| - m_currentSourceNode = nullptr;
|
| - m_nextChildNodeToConsider = nullptr;
|
| - }
|
| -
|
| -#if !LOG_DISABLED
|
| - if (shouldLog)
|
| - WTF_LOG(Media, "HTMLMediaElement::selectNextSourceChild -> %p, %s", m_currentSourceNode.get(), canUseSourceElement ? urlForLoggingMedia(mediaURL).utf8().data() : "");
|
| -#endif
|
| - return canUseSourceElement ? mediaURL : KURL();
|
| -}
|
| -
|
| -void HTMLMediaElement::sourceWasAdded(HTMLSourceElement* source)
|
| -{
|
| - WTF_LOG(Media, "HTMLMediaElement::sourceWasAdded(%p)", source);
|
| -
|
| -#if !LOG_DISABLED
|
| - KURL url = source->getNonEmptyURLAttribute(HTMLNames::srcAttr);
|
| - WTF_LOG(Media, "HTMLMediaElement::sourceWasAdded - 'src' is %s", urlForLoggingMedia(url).utf8().data());
|
| -#endif
|
| -
|
| - // We should only consider a <source> element when there is not src attribute at all.
|
| - if (hasAttribute(HTMLNames::srcAttr))
|
| - return;
|
| -
|
| - // 4.8.8 - If a source element is inserted as a child of a media element that has no src
|
| - // attribute and whose networkState has the value NETWORK_EMPTY, the user agent must invoke
|
| - // the media element's resource selection algorithm.
|
| - if (networkState() == HTMLMediaElement::NETWORK_EMPTY) {
|
| - scheduleDelayedAction(LoadMediaResource);
|
| - m_nextChildNodeToConsider = source;
|
| - return;
|
| - }
|
| -
|
| - if (m_currentSourceNode && source == m_currentSourceNode->nextSibling()) {
|
| - WTF_LOG(Media, "HTMLMediaElement::sourceWasAdded - <source> inserted immediately after current source");
|
| - m_nextChildNodeToConsider = source;
|
| - return;
|
| - }
|
| -
|
| - if (m_nextChildNodeToConsider)
|
| - return;
|
| -
|
| - if (m_loadState != WaitingForSource)
|
| - return;
|
| -
|
| - // 4.8.9.5, resource selection algorithm, source elements section:
|
| - // 21. Wait until the node after pointer is a node other than the end of the list. (This step might wait forever.)
|
| - // 22. Asynchronously await a stable state...
|
| - // 23. Set the element's delaying-the-load-event flag back to true (this delays the load event again, in case
|
| - // it hasn't been fired yet).
|
| - setShouldDelayLoadEvent(true);
|
| -
|
| - // 24. Set the networkState back to NETWORK_LOADING.
|
| - m_networkState = NETWORK_LOADING;
|
| -
|
| - // 25. Jump back to the find next candidate step above.
|
| - m_nextChildNodeToConsider = source;
|
| - scheduleNextSourceChild();
|
| -}
|
| -
|
| -void HTMLMediaElement::sourceWasRemoved(HTMLSourceElement* source)
|
| -{
|
| - WTF_LOG(Media, "HTMLMediaElement::sourceWasRemoved(%p)", source);
|
| -
|
| -#if !LOG_DISABLED
|
| - KURL url = source->getNonEmptyURLAttribute(HTMLNames::srcAttr);
|
| - WTF_LOG(Media, "HTMLMediaElement::sourceWasRemoved - 'src' is %s", urlForLoggingMedia(url).utf8().data());
|
| -#endif
|
| -
|
| - if (source != m_currentSourceNode && source != m_nextChildNodeToConsider)
|
| - return;
|
| -
|
| - if (source == m_nextChildNodeToConsider) {
|
| - if (m_currentSourceNode)
|
| - m_nextChildNodeToConsider = m_currentSourceNode->nextSibling();
|
| - WTF_LOG(Media, "HTMLMediaElement::sourceRemoved - m_nextChildNodeToConsider set to %p", m_nextChildNodeToConsider.get());
|
| - } else if (source == m_currentSourceNode) {
|
| - // Clear the current source node pointer, but don't change the movie as the spec says:
|
| - // 4.8.8 - Dynamically modifying a source element and its attribute when the element is already
|
| - // inserted in a video or audio element will have no effect.
|
| - m_currentSourceNode = nullptr;
|
| - WTF_LOG(Media, "HTMLMediaElement::sourceRemoved - m_currentSourceNode set to 0");
|
| - }
|
| -}
|
| -
|
| -void HTMLMediaElement::mediaPlayerTimeChanged()
|
| -{
|
| - WTF_LOG(Media, "HTMLMediaElement::mediaPlayerTimeChanged");
|
| -
|
| - invalidateCachedTime();
|
| -
|
| - // 4.8.10.9 steps 12-14. Needed if no ReadyState change is associated with the seek.
|
| - if (m_seeking && m_readyState >= HAVE_CURRENT_DATA && !webMediaPlayer()->seeking())
|
| - finishSeek();
|
| -
|
| - // Always call scheduleTimeupdateEvent when the media engine reports a time discontinuity,
|
| - // it will only queue a 'timeupdate' event if we haven't already posted one at the current
|
| - // movie time.
|
| - scheduleTimeupdateEvent(false);
|
| -
|
| - double now = currentTime();
|
| - double dur = duration();
|
| -
|
| - // When the current playback position reaches the end of the media resource when the direction of
|
| - // playback is forwards, then the user agent must follow these steps:
|
| - if (!std::isnan(dur) && dur && now >= dur && directionOfPlayback() == Forward) {
|
| - // If the media element has a loop attribute specified and does not have a current media controller,
|
| - if (loop()) {
|
| - m_sentEndEvent = false;
|
| - // then seek to the earliest possible position of the media resource and abort these steps.
|
| - seek(0, IGNORE_EXCEPTION);
|
| - } else {
|
| - // If the media element does not have a current media controller, and the media element
|
| - // has still ended playback, and the direction of playback is still forwards, and paused
|
| - // is false,
|
| - if (!m_paused) {
|
| - // changes paused to true and fires a simple event named pause at the media element.
|
| - m_paused = true;
|
| - scheduleEvent(EventTypeNames::pause);
|
| - }
|
| - // Queue a task to fire a simple event named ended at the media element.
|
| - if (!m_sentEndEvent) {
|
| - m_sentEndEvent = true;
|
| - scheduleEvent(EventTypeNames::ended);
|
| - }
|
| - }
|
| - }
|
| - else
|
| - m_sentEndEvent = false;
|
| -
|
| - updatePlayState();
|
| -}
|
| -
|
| -void HTMLMediaElement::mediaPlayerDurationChanged()
|
| -{
|
| - WTF_LOG(Media, "HTMLMediaElement::mediaPlayerDurationChanged");
|
| - // FIXME: Change MediaPlayerClient & WebMediaPlayer to convey
|
| - // the currentTime when the duration change occured. The current
|
| - // WebMediaPlayer implementations always clamp currentTime() to
|
| - // duration() so the requestSeek condition here is always false.
|
| - durationChanged(duration(), currentTime() > duration());
|
| -}
|
| -
|
| -void HTMLMediaElement::durationChanged(double duration, bool requestSeek)
|
| -{
|
| - WTF_LOG(Media, "HTMLMediaElement::durationChanged(%f, %d)", duration, requestSeek);
|
| -
|
| - // Abort if duration unchanged.
|
| - if (m_duration == duration)
|
| - return;
|
| -
|
| - WTF_LOG(Media, "HTMLMediaElement::durationChanged : %f -> %f", m_duration, duration);
|
| - m_duration = duration;
|
| - scheduleEvent(EventTypeNames::durationchange);
|
| -
|
| - if (renderer())
|
| - renderer()->updateFromElement();
|
| -
|
| - if (requestSeek)
|
| - seek(duration, IGNORE_EXCEPTION);
|
| -}
|
| -
|
| -void HTMLMediaElement::mediaPlayerPlaybackStateChanged()
|
| -{
|
| - WTF_LOG(Media, "HTMLMediaElement::mediaPlayerPlaybackStateChanged");
|
| -
|
| - if (!m_player || m_pausedInternal)
|
| - return;
|
| -
|
| - if (webMediaPlayer()->paused())
|
| - pause();
|
| - else
|
| - playInternal();
|
| -}
|
| -
|
| -void HTMLMediaElement::mediaPlayerRequestFullscreen()
|
| -{
|
| - // FIXME(sky): How do we go full screen now?
|
| -}
|
| -
|
| -void HTMLMediaElement::mediaPlayerRequestSeek(double time)
|
| -{
|
| - setCurrentTime(time, IGNORE_EXCEPTION);
|
| -}
|
| -
|
| -// MediaPlayerPresentation methods
|
| -void HTMLMediaElement::mediaPlayerRepaint()
|
| -{
|
| - if (m_webLayer)
|
| - m_webLayer->invalidate();
|
| -
|
| - updateDisplayState();
|
| - if (renderer())
|
| - renderer()->setShouldDoFullPaintInvalidation(true);
|
| -}
|
| -
|
| -void HTMLMediaElement::mediaPlayerSizeChanged()
|
| -{
|
| - WTF_LOG(Media, "HTMLMediaElement::mediaPlayerSizeChanged");
|
| -
|
| - if (renderer())
|
| - renderer()->updateFromElement();
|
| -}
|
| -
|
| -PassRefPtr<TimeRanges> HTMLMediaElement::buffered() const
|
| -{
|
| - if (m_mediaSource)
|
| - return m_mediaSource->buffered();
|
| -
|
| - if (!webMediaPlayer())
|
| - return TimeRanges::create();
|
| -
|
| - return TimeRanges::create(webMediaPlayer()->buffered());
|
| -}
|
| -
|
| -PassRefPtr<TimeRanges> HTMLMediaElement::played()
|
| -{
|
| - if (m_playing) {
|
| - double time = currentTime();
|
| - if (time > m_lastSeekTime)
|
| - addPlayedRange(m_lastSeekTime, time);
|
| - }
|
| -
|
| - if (!m_playedTimeRanges)
|
| - m_playedTimeRanges = TimeRanges::create();
|
| -
|
| - return m_playedTimeRanges->copy();
|
| -}
|
| -
|
| -PassRefPtr<TimeRanges> HTMLMediaElement::seekable() const
|
| -{
|
| - if (webMediaPlayer()) {
|
| - double maxTimeSeekable = webMediaPlayer()->maxTimeSeekable();
|
| - if (maxTimeSeekable)
|
| - return TimeRanges::create(0, maxTimeSeekable);
|
| - }
|
| - return TimeRanges::create();
|
| -}
|
| -
|
| -bool HTMLMediaElement::potentiallyPlaying() const
|
| -{
|
| - // "pausedToBuffer" means the media engine's rate is 0, but only because it had to stop playing
|
| - // when it ran out of buffered data. A movie is this state is "potentially playing", modulo the
|
| - // checks in couldPlayIfEnoughData().
|
| - bool pausedToBuffer = m_readyStateMaximum >= HAVE_FUTURE_DATA && m_readyState < HAVE_FUTURE_DATA;
|
| - return (pausedToBuffer || m_readyState >= HAVE_FUTURE_DATA) && couldPlayIfEnoughData();
|
| -}
|
| -
|
| -bool HTMLMediaElement::couldPlayIfEnoughData() const
|
| -{
|
| - return !paused() && !endedPlayback() && !stoppedDueToErrors();
|
| -}
|
| -
|
| -bool HTMLMediaElement::endedPlayback() const
|
| -{
|
| - double dur = duration();
|
| - if (!m_player || std::isnan(dur))
|
| - return false;
|
| -
|
| - // 4.8.10.8 Playing the media resource
|
| -
|
| - // A media element is said to have ended playback when the element's
|
| - // readyState attribute is HAVE_METADATA or greater,
|
| - if (m_readyState < HAVE_METADATA)
|
| - return false;
|
| -
|
| - // and the current playback position is the end of the media resource and the direction
|
| - // of playback is forwards, Either the media element does not have a loop attribute specified,
|
| - // or the media element has a current media controller.
|
| - double now = currentTime();
|
| - if (directionOfPlayback() == Forward)
|
| - return dur > 0 && now >= dur && !loop();
|
| -
|
| - // or the current playback position is the earliest possible position and the direction
|
| - // of playback is backwards
|
| - ASSERT(directionOfPlayback() == Backward);
|
| - return now <= 0;
|
| -}
|
| -
|
| -bool HTMLMediaElement::stoppedDueToErrors() const
|
| -{
|
| - if (m_readyState >= HAVE_METADATA && m_error) {
|
| - RefPtr<TimeRanges> seekableRanges = seekable();
|
| - if (!seekableRanges->contain(currentTime()))
|
| - return true;
|
| - }
|
| -
|
| - return false;
|
| -}
|
| -
|
| -void HTMLMediaElement::updatePlayState()
|
| -{
|
| - if (!m_player)
|
| - return;
|
| -
|
| - bool isPlaying = webMediaPlayer() && !webMediaPlayer()->paused();
|
| - if (m_pausedInternal) {
|
| - if (isPlaying)
|
| - webMediaPlayer()->pause();
|
| - refreshCachedTime();
|
| - m_playbackProgressTimer.stop();
|
| - return;
|
| - }
|
| -
|
| - bool shouldBePlaying = potentiallyPlaying();
|
| -
|
| - WTF_LOG(Media, "HTMLMediaElement::updatePlayState - shouldBePlaying = %s, isPlaying = %s",
|
| - boolString(shouldBePlaying), boolString(isPlaying));
|
| -
|
| - if (shouldBePlaying) {
|
| - setDisplayMode(Video);
|
| - invalidateCachedTime();
|
| -
|
| - if (!isPlaying) {
|
| - // Set rate, muted before calling play in case they were set before the media engine was setup.
|
| - // The media engine should just stash the rate and muted values since it isn't already playing.
|
| - webMediaPlayer()->setRate(effectivePlaybackRate());
|
| - updateVolume();
|
| - webMediaPlayer()->play();
|
| - }
|
| -
|
| - startPlaybackProgressTimer();
|
| - m_playing = true;
|
| -
|
| - } else { // Should not be playing right now
|
| - if (isPlaying)
|
| - webMediaPlayer()->pause();
|
| - refreshCachedTime();
|
| -
|
| - m_playbackProgressTimer.stop();
|
| - m_playing = false;
|
| - double time = currentTime();
|
| - if (time > m_lastSeekTime)
|
| - addPlayedRange(m_lastSeekTime, time);
|
| -
|
| - if (couldPlayIfEnoughData())
|
| - prepareToPlay();
|
| - }
|
| -
|
| - if (renderer())
|
| - renderer()->updateFromElement();
|
| -}
|
| -
|
| -void HTMLMediaElement::setPausedInternal(bool b)
|
| -{
|
| - m_pausedInternal = b;
|
| - updatePlayState();
|
| -}
|
| -
|
| -void HTMLMediaElement::stopPeriodicTimers()
|
| -{
|
| - m_progressEventTimer.stop();
|
| - m_playbackProgressTimer.stop();
|
| -}
|
| -
|
| -void HTMLMediaElement::userCancelledLoad()
|
| -{
|
| - WTF_LOG(Media, "HTMLMediaElement::userCancelledLoad");
|
| -
|
| - // If the media data fetching process is aborted by the user:
|
| -
|
| - // 1 - The user agent should cancel the fetching process.
|
| - clearMediaPlayer(-1);
|
| -
|
| - if (m_networkState == NETWORK_EMPTY || m_completelyLoaded)
|
| - return;
|
| -
|
| - // 2 - Set the error attribute to a new MediaError object whose code attribute is set to MEDIA_ERR_ABORTED.
|
| - m_error = MediaError::create(MediaError::MEDIA_ERR_ABORTED);
|
| -
|
| - // 3 - Queue a task to fire a simple event named error at the media element.
|
| - scheduleEvent(EventTypeNames::abort);
|
| -
|
| - closeMediaSource();
|
| -
|
| - // 4 - If the media element's readyState attribute has a value equal to HAVE_NOTHING, set the
|
| - // element's networkState attribute to the NETWORK_EMPTY value and queue a task to fire a
|
| - // simple event named emptied at the element. Otherwise, set the element's networkState
|
| - // attribute to the NETWORK_IDLE value.
|
| - if (m_readyState == HAVE_NOTHING) {
|
| - m_networkState = NETWORK_EMPTY;
|
| - scheduleEvent(EventTypeNames::emptied);
|
| - }
|
| - else
|
| - m_networkState = NETWORK_IDLE;
|
| -
|
| - // 5 - Set the element's delaying-the-load-event flag to false. This stops delaying the load event.
|
| - setShouldDelayLoadEvent(false);
|
| -
|
| - // 6 - Abort the overall resource selection algorithm.
|
| - m_currentSourceNode = nullptr;
|
| -
|
| - // Reset m_readyState since m_player is gone.
|
| - m_readyState = HAVE_NOTHING;
|
| - invalidateCachedTime();
|
| -}
|
| -
|
| -void HTMLMediaElement::clearMediaPlayerAndAudioSourceProviderClientWithoutLocking()
|
| -{
|
| - m_player.clear();
|
| -}
|
| -
|
| -void HTMLMediaElement::clearMediaPlayer(int flags)
|
| -{
|
| - closeMediaSource();
|
| -
|
| - cancelDeferredLoad();
|
| - clearMediaPlayerAndAudioSourceProviderClientWithoutLocking();
|
| -
|
| - stopPeriodicTimers();
|
| - m_loadTimer.stop();
|
| -
|
| - m_pendingActionFlags &= ~flags;
|
| - m_loadState = WaitingForSource;
|
| -}
|
| -
|
| -void HTMLMediaElement::stop()
|
| -{
|
| - WTF_LOG(Media, "HTMLMediaElement::stop");
|
| -
|
| - m_active = false;
|
| - userCancelledLoad();
|
| -
|
| - // Stop the playback without generating events
|
| - m_playing = false;
|
| - setPausedInternal(true);
|
| -
|
| - if (renderer())
|
| - renderer()->updateFromElement();
|
| -
|
| - stopPeriodicTimers();
|
| - cancelPendingEventsAndCallbacks();
|
| -
|
| - m_asyncEventQueue->close();
|
| -}
|
| -
|
| -bool HTMLMediaElement::hasPendingActivity() const
|
| -{
|
| - return (hasAudio() && isPlaying()) || m_asyncEventQueue->hasPendingEvents();
|
| -}
|
| -
|
| -void HTMLMediaElement::contextDestroyed()
|
| -{
|
| - ActiveDOMObject::contextDestroyed();
|
| -}
|
| -
|
| -bool HTMLMediaElement::isFullscreen() const
|
| -{
|
| - // FIXME(sky): How does video go full screen now?
|
| - return false;
|
| -}
|
| -
|
| -void HTMLMediaElement::enterFullscreen()
|
| -{
|
| -}
|
| -
|
| -void HTMLMediaElement::exitFullscreen()
|
| -{
|
| -}
|
| -
|
| -blink::WebLayer* HTMLMediaElement::platformLayer() const
|
| -{
|
| - return m_webLayer;
|
| -}
|
| -
|
| -bool HTMLMediaElement::isURLAttribute(const Attribute& attribute) const
|
| -{
|
| - return attribute.name() == HTMLNames::srcAttr || HTMLElement::isURLAttribute(attribute);
|
| -}
|
| -
|
| -void HTMLMediaElement::setShouldDelayLoadEvent(bool shouldDelay)
|
| -{
|
| - if (m_shouldDelayLoadEvent == shouldDelay)
|
| - return;
|
| -
|
| - WTF_LOG(Media, "HTMLMediaElement::setShouldDelayLoadEvent(%s)", boolString(shouldDelay));
|
| -
|
| - m_shouldDelayLoadEvent = shouldDelay;
|
| - if (shouldDelay)
|
| - document().incrementLoadEventDelayCount();
|
| - else
|
| - document().decrementLoadEventDelayCount();
|
| -}
|
| -
|
| -void* HTMLMediaElement::preDispatchEventHandler(Event* event)
|
| -{
|
| - return 0;
|
| -}
|
| -
|
| -void HTMLMediaElement::createMediaPlayer()
|
| -{
|
| - closeMediaSource();
|
| - m_player = MediaPlayer::create(this);
|
| -}
|
| -
|
| -const AtomicString& HTMLMediaElement::mediaGroup() const
|
| -{
|
| - return getAttribute(HTMLNames::mediagroupAttr);
|
| -}
|
| -
|
| -bool HTMLMediaElement::isBlocked() const
|
| -{
|
| - // A media element is a blocked media element if its readyState attribute is in the
|
| - // HAVE_NOTHING state, the HAVE_METADATA state, or the HAVE_CURRENT_DATA state,
|
| - // or if the element has paused for user interaction or paused for in-band content.
|
| - if (m_readyState <= HAVE_CURRENT_DATA)
|
| - return true;
|
| -
|
| - return false;
|
| -}
|
| -
|
| -void HTMLMediaElement::prepareMediaFragmentURI()
|
| -{
|
| - MediaFragmentURIParser fragmentParser(m_currentSrc);
|
| - double dur = duration();
|
| -
|
| - double start = fragmentParser.startTime();
|
| - if (start != MediaFragmentURIParser::invalidTimeValue() && start > 0) {
|
| - m_fragmentStartTime = start;
|
| - if (m_fragmentStartTime > dur)
|
| - m_fragmentStartTime = dur;
|
| - } else
|
| - m_fragmentStartTime = MediaPlayer::invalidTime();
|
| -
|
| - double end = fragmentParser.endTime();
|
| - if (end != MediaFragmentURIParser::invalidTimeValue() && end > 0 && end > m_fragmentStartTime) {
|
| - m_fragmentEndTime = end;
|
| - if (m_fragmentEndTime > dur)
|
| - m_fragmentEndTime = dur;
|
| - } else
|
| - m_fragmentEndTime = MediaPlayer::invalidTime();
|
| -
|
| - if (m_fragmentStartTime != MediaPlayer::invalidTime() && m_readyState < HAVE_FUTURE_DATA)
|
| - prepareToPlay();
|
| -}
|
| -
|
| -void HTMLMediaElement::applyMediaFragmentURI()
|
| -{
|
| - if (m_fragmentStartTime != MediaPlayer::invalidTime()) {
|
| - m_sentEndEvent = false;
|
| - UseCounter::count(document(), UseCounter::HTMLMediaElementSeekToFragmentStart);
|
| - seek(m_fragmentStartTime, IGNORE_EXCEPTION);
|
| - }
|
| -}
|
| -
|
| -WebMediaPlayer::CORSMode HTMLMediaElement::corsMode() const
|
| -{
|
| - const AtomicString& crossOriginMode = getAttribute(HTMLNames::crossoriginAttr);
|
| - if (crossOriginMode.isNull())
|
| - return WebMediaPlayer::CORSModeUnspecified;
|
| - if (equalIgnoringCase(crossOriginMode, "use-credentials"))
|
| - return WebMediaPlayer::CORSModeUseCredentials;
|
| - return WebMediaPlayer::CORSModeAnonymous;
|
| -}
|
| -
|
| -void HTMLMediaElement::mediaPlayerSetWebLayer(blink::WebLayer* webLayer)
|
| -{
|
| - if (webLayer == m_webLayer)
|
| - return;
|
| -
|
| - // If either of the layers is null we need to enable or disable compositing. This is done by triggering a style recalc.
|
| - if (!m_webLayer || !webLayer)
|
| - setNeedsCompositingUpdate();
|
| -
|
| - if (m_webLayer)
|
| - GraphicsLayer::unregisterContentsLayer(m_webLayer);
|
| - m_webLayer = webLayer;
|
| - if (m_webLayer) {
|
| - GraphicsLayer::registerContentsLayer(m_webLayer);
|
| - }
|
| -}
|
| -
|
| -void HTMLMediaElement::mediaPlayerMediaSourceOpened(blink::WebMediaSource* webMediaSource)
|
| -{
|
| - m_mediaSource->setWebMediaSourceAndOpen(adoptPtr(webMediaSource));
|
| -}
|
| -
|
| -void HTMLMediaElement::defaultEventHandler(Event* event)
|
| -{
|
| - HTMLElement::defaultEventHandler(event);
|
| -}
|
| -
|
| -}
|
|
|
Chromium Code Reviews
Issue 689373003:
Remove most of the media stack. (Closed)
Base URL: git@github.com:domokit/mojo.git@master