1 /*

     2  * Copyright (C) 2007, 2008, 2009, 2010 Apple Inc. All rights reserved.

     3  *

     4  * Redistribution and use in source and binary forms, with or without

     5  * modification, are permitted provided that the following conditions

     6  * are met:

     7  * 1. Redistributions of source code must retain the above copyright

     8  *    notice, this list of conditions and the following disclaimer.

     9  * 2. Redistributions in binary form must reproduce the above copyright

    10  *    notice, this list of conditions and the following disclaimer in the

    11  *    documentation and/or other materials provided with the distribution.

    12  *

    13  * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY

    14  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

    15  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR

    16  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR

    17  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,

    18  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,

    19  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR

    20  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY

    21  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

    22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

    23  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 

    24  */

    25 

    26 #include "config.h"

    27 

    28 #if ENABLE(VIDEO)

    29 #include "HTMLMediaElement.h"

    30 

    31 #include "Attribute.h"

    32 #include "CSSHelper.h"

    33 #include "CSSPropertyNames.h"

    34 #include "CSSValueKeywords.h"

    35 #include "Chrome.h"

    36 #include "ChromeClient.h"

    37 #include "ClientRect.h"

    38 #include "ClientRectList.h"

    39 #include "ContentType.h"

    40 #include "DocLoader.h"

    41 #include "Event.h"

    42 #include "EventNames.h"

    43 #include "ExceptionCode.h"

    44 #include "Frame.h"

    45 #include "FrameLoader.h"

    46 #include "FrameLoaderClient.h"

    47 #include "FrameView.h"

    48 #include "HTMLDocument.h"

    49 #include "HTMLNames.h"

    50 #include "HTMLSourceElement.h"

    51 #include "HTMLVideoElement.h"

    52 #include "MIMETypeRegistry.h"

    53 #include "MediaDocument.h"

    54 #include "MediaError.h"

    55 #include "MediaList.h"

    56 #include "MediaPlayer.h"

    57 #include "MediaQueryEvaluator.h"

    58 #include "Page.h"

    59 #include "RenderVideo.h"

    60 #include "RenderView.h"

    61 #include "ScriptEventListener.h"

    62 #include "Settings.h"

    63 #include "TimeRanges.h"

    64 #include <limits>

    65 #include <wtf/CurrentTime.h>

    66 #include <wtf/MathExtras.h>

    67 

    68 #if USE(ACCELERATED_COMPOSITING)

    69 #include "RenderView.h"

    70 #include "RenderLayerCompositor.h"

    71 #endif

    72 

    73 #if ENABLE(PLUGIN_PROXY_FOR_VIDEO)

    74 #include "RenderEmbeddedObject.h"

    75 #include "Widget.h"

    76 #endif

    77 

    78 using namespace std;

    79 

    80 namespace WebCore {

    81 

    82 using namespace HTMLNames;

    83 

    84 HTMLMediaElement::HTMLMediaElement(const QualifiedName& tagName, Document* doc)

    85     : HTMLElement(tagName, doc)

    86     , m_loadTimer(this, &HTMLMediaElement::loadTimerFired)

    87     , m_asyncEventTimer(this, &HTMLMediaElement::asyncEventTimerFired)

    88     , m_progressEventTimer(this, &HTMLMediaElement::progressEventTimerFired)

    89     , m_playbackProgressTimer(this, &HTMLMediaElement::playbackProgressTimerFired)

    90     , m_playedTimeRanges()

    91     , m_playbackRate(1.0f)

    92     , m_defaultPlaybackRate(1.0f)

    93     , m_webkitPreservesPitch(true)

    94     , m_networkState(NETWORK_EMPTY)

    95     , m_readyState(HAVE_NOTHING)

    96     , m_readyStateMaximum(HAVE_NOTHING)

    97     , m_volume(1.0f)

    98     , m_lastSeekTime(0)

    99     , m_previousProgress(0)

   100     , m_previousProgressTime(numeric_limits<double>::max())

   101     , m_lastTimeUpdateEventWallTime(0)

   102     , m_lastTimeUpdateEventMovieTime(numeric_limits<float>::max())

   103     , m_loadState(WaitingForSource)

   104     , m_currentSourceNode(0)

   105     , m_player(0)

   106 #if ENABLE(PLUGIN_PROXY_FOR_VIDEO)

   107     , m_proxyWidget(0)

   108 #endif

   109     , m_restrictions(NoRestrictions)

   110     , m_preload(MediaPlayer::Auto)

   111     , m_playing(false)

   112     , m_processingMediaPlayerCallback(0)

   113     , m_isWaitingUntilMediaCanStart(false)

   114     , m_processingLoad(false)

   115     , m_delayingTheLoadEvent(false)

   116     , m_haveFiredLoadedData(false)

   117     , m_inActiveDocument(true)

   118     , m_autoplaying(true)

   119     , m_muted(false)

   120     , m_paused(true)

   121     , m_seeking(false)

   122     , m_sentStalledEvent(false)

   123     , m_sentEndEvent(false)

   124     , m_pausedInternal(false)

   125     , m_sendProgressEvents(true)

   126     , m_isFullscreen(false)

   127     , m_closedCaptionsVisible(false)

   128 #if ENABLE(PLUGIN_PROXY_FOR_VIDEO)

   129     , m_needWidgetUpdate(false)

   130 #endif

   131     , m_dispatchingCanPlayEvent(false)

   132     , m_loadInitiatedByUserGesture(false)

   133     , m_completelyLoaded(false)

   134 {

   135     document()->registerForDocumentActivationCallbacks(this);

   136     document()->registerForMediaVolumeCallbacks(this);

   137 }

   138 

   139 HTMLMediaElement::~HTMLMediaElement()

   140 {

   141     if (m_isWaitingUntilMediaCanStart)

   142         document()->removeMediaCanStartListener(this);

   143     document()->unregisterForDocumentActivationCallbacks(this);

   144     document()->unregisterForMediaVolumeCallbacks(this);

   145 }

   146 

   147 void HTMLMediaElement::willMoveToNewOwnerDocument()

   148 {

   149     if (m_isWaitingUntilMediaCanStart)

   150         document()->removeMediaCanStartListener(this);

   151     document()->unregisterForDocumentActivationCallbacks(this);

   152     document()->unregisterForMediaVolumeCallbacks(this);

   153     HTMLElement::willMoveToNewOwnerDocument();

   154 }

   155 

   156 void HTMLMediaElement::didMoveToNewOwnerDocument()

   157 {

   158     if (m_isWaitingUntilMediaCanStart)

   159         document()->addMediaCanStartListener(this);

   160     document()->registerForDocumentActivationCallbacks(this);

   161     document()->registerForMediaVolumeCallbacks(this);

   162     HTMLElement::didMoveToNewOwnerDocument();

   163 }

   164 

   165 

   166 bool HTMLMediaElement::checkDTD(const Node* newChild)

   167 {

   168     return newChild->hasTagName(sourceTag) || HTMLElement::checkDTD(newChild);

   169 }

   170 

   171 void HTMLMediaElement::attributeChanged(Attribute* attr, bool preserveDecls)

   172 {

   173     HTMLElement::attributeChanged(attr, preserveDecls);

   174 

   175     const QualifiedName& attrName = attr->name();

   176     if (attrName == srcAttr) {

   177         // Trigger a reload, as long as the 'src' attribute is present.

   178         if (!getAttribute(srcAttr).isEmpty())

   179             scheduleLoad();

   180     }

   181     else if (attrName == controlsAttr) {

   182 #if !ENABLE(PLUGIN_PROXY_FOR_VIDEO)

   183         if (!isVideo() && attached() && (controls() != (renderer() != 0))) {

   184             detach();

   185             attach();

   186         }

   187         if (renderer())

   188             renderer()->updateFromElement();

   189 #else

   190         if (m_player)

   191             m_player->setControls(controls());

   192 #endif

   193     }

   194 }

   195 

   196 void HTMLMediaElement::parseMappedAttribute(Attribute* attr)

   197 {

   198     const QualifiedName& attrName = attr->name();

   199 

   200     if (attrName == preloadAttr) {

   201         String value = attr->value();

   202 

   203         if (equalIgnoringCase(value, "none"))

   204             m_preload = MediaPlayer::None;

   205         else if (equalIgnoringCase(value, "metadata"))

   206             m_preload = MediaPlayer::MetaData;

   207         else {

   208             // The spec does not define an "invalid value default" but "auto" is suggested as the

   209             // "missing value default", so use it for everything except "none" and "metadata"

   210             m_preload = MediaPlayer::Auto;

   211         }

   212 

   213         // The attribute must be ignored if the autoplay attribute is present

   214         if (!autoplay() && m_player)

   215             m_player->setPreload(m_preload);

   216 

   217     } else if (attrName == onabortAttr)

   218         setAttributeEventListener(eventNames().abortEvent, createAttributeEventListener(this, attr));

   219     else if (attrName == onbeforeloadAttr)

   220         setAttributeEventListener(eventNames().beforeloadEvent, createAttributeEventListener(this, attr));

   221     else if (attrName == oncanplayAttr)

   222         setAttributeEventListener(eventNames().canplayEvent, createAttributeEventListener(this, attr));

   223     else if (attrName == oncanplaythroughAttr)

   224         setAttributeEventListener(eventNames().canplaythroughEvent, createAttributeEventListener(this, attr));

   225     else if (attrName == ondurationchangeAttr)

   226         setAttributeEventListener(eventNames().durationchangeEvent, createAttributeEventListener(this, attr));

   227     else if (attrName == onemptiedAttr)

   228         setAttributeEventListener(eventNames().emptiedEvent, createAttributeEventListener(this, attr));

   229     else if (attrName == onendedAttr)

   230         setAttributeEventListener(eventNames().endedEvent, createAttributeEventListener(this, attr));

   231     else if (attrName == onerrorAttr)

   232         setAttributeEventListener(eventNames().errorEvent, createAttributeEventListener(this, attr));

   233     else if (attrName == onloadeddataAttr)

   234         setAttributeEventListener(eventNames().loadeddataEvent, createAttributeEventListener(this, attr));

   235     else if (attrName == onloadedmetadataAttr)

   236         setAttributeEventListener(eventNames().loadedmetadataEvent, createAttributeEventListener(this, attr));

   237     else if (attrName == onloadstartAttr)

   238         setAttributeEventListener(eventNames().loadstartEvent, createAttributeEventListener(this, attr));

   239     else if (attrName == onpauseAttr)

   240         setAttributeEventListener(eventNames().pauseEvent, createAttributeEventListener(this, attr));

   241     else if (attrName == onplayAttr)

   242         setAttributeEventListener(eventNames().playEvent, createAttributeEventListener(this, attr));

   243     else if (attrName == onplayingAttr)

   244         setAttributeEventListener(eventNames().playingEvent, createAttributeEventListener(this, attr));

   245     else if (attrName == onprogressAttr)

   246         setAttributeEventListener(eventNames().progressEvent, createAttributeEventListener(this, attr));

   247     else if (attrName == onratechangeAttr)

   248         setAttributeEventListener(eventNames().ratechangeEvent, createAttributeEventListener(this, attr));

   249     else if (attrName == onseekedAttr)

   250         setAttributeEventListener(eventNames().seekedEvent, createAttributeEventListener(this, attr));

   251     else if (attrName == onseekingAttr)

   252         setAttributeEventListener(eventNames().seekingEvent, createAttributeEventListener(this, attr));

   253     else if (attrName == onstalledAttr)

   254         setAttributeEventListener(eventNames().stalledEvent, createAttributeEventListener(this, attr));

   255     else if (attrName == onsuspendAttr)

   256         setAttributeEventListener(eventNames().suspendEvent, createAttributeEventListener(this, attr));

   257     else if (attrName == ontimeupdateAttr)

   258         setAttributeEventListener(eventNames().timeupdateEvent, createAttributeEventListener(this, attr));

   259     else if (attrName == onvolumechangeAttr)

   260         setAttributeEventListener(eventNames().volumechangeEvent, createAttributeEventListener(this, attr));

   261     else if (attrName == onwaitingAttr)

   262         setAttributeEventListener(eventNames().waitingEvent, createAttributeEventListener(this, attr));

   263     else if (attrName == onwebkitbeginfullscreenAttr)

   264         setAttributeEventListener(eventNames().webkitbeginfullscreenEvent, createAttributeEventListener(this, attr));

   265     else if (attrName == onwebkitendfullscreenAttr)

   266         setAttributeEventListener(eventNames().webkitendfullscreenEvent, createAttributeEventListener(this, attr));

   267     else

   268         HTMLElement::parseMappedAttribute(attr);

   269 }

   270 

   271 bool HTMLMediaElement::rendererIsNeeded(RenderStyle* style)

   272 {

   273 #if ENABLE(PLUGIN_PROXY_FOR_VIDEO)

   274     UNUSED_PARAM(style);

   275     Frame* frame = document()->frame();

   276     if (!frame)

   277         return false;

   278 

   279     return true;

   280 #else

   281     return controls() ? HTMLElement::rendererIsNeeded(style) : false;

   282 #endif

   283 }

   284 

   285 RenderObject* HTMLMediaElement::createRenderer(RenderArena* arena, RenderStyle*)

   286 {

   287 #if ENABLE(PLUGIN_PROXY_FOR_VIDEO)

   288     // Setup the renderer if we already have a proxy widget.

   289     RenderEmbeddedObject* mediaRenderer = new (arena) RenderEmbeddedObject(this);

   290     if (m_proxyWidget) {

   291         mediaRenderer->setWidget(m_proxyWidget);

   292 

   293         Frame* frame = document()->frame();

   294         FrameLoader* loader = frame ? frame->loader() : 0;

   295         if (loader)

   296             loader->showMediaPlayerProxyPlugin(m_proxyWidget.get());

   297     }

   298     return mediaRenderer;

   299 #else

   300     return new (arena) RenderMedia(this);

   301 #endif

   302 }

   303  

   304 void HTMLMediaElement::insertedIntoDocument()

   305 {

   306     HTMLElement::insertedIntoDocument();

   307     if (!src().isEmpty() && m_networkState == NETWORK_EMPTY)

   308         scheduleLoad();

   309 }

   310 

   311 void HTMLMediaElement::removedFromDocument()

   312 {

   313     if (m_networkState > NETWORK_EMPTY)

   314         pause(processingUserGesture());

   315     if (m_isFullscreen)

   316         exitFullscreen();

   317     HTMLElement::removedFromDocument();

   318 }

   319 

   320 void HTMLMediaElement::attach()

   321 {

   322     ASSERT(!attached());

   323 

   324 #if ENABLE(PLUGIN_PROXY_FOR_VIDEO)

   325     m_needWidgetUpdate = true;

   326 #endif

   327 

   328     HTMLElement::attach();

   329 

   330     if (renderer())

   331         renderer()->updateFromElement();

   332 #if ENABLE(PLUGIN_PROXY_FOR_VIDEO)

   333     else if (m_proxyWidget) {

   334         Frame* frame = document()->frame();

   335         FrameLoader* loader = frame ? frame->loader() : 0;

   336         if (loader)

   337             loader->hideMediaPlayerProxyPlugin(m_proxyWidget.get());

   338     }

   339 #endif

   340 }

   341 

   342 void HTMLMediaElement::recalcStyle(StyleChange change)

   343 {

   344     HTMLElement::recalcStyle(change);

   345 

   346     if (renderer())

   347         renderer()->updateFromElement();

   348 }

   349 

   350 void HTMLMediaElement::scheduleLoad()

   351 {

   352 #if ENABLE(PLUGIN_PROXY_FOR_VIDEO)

   353     createMediaPlayerProxy();

   354 #endif

   355 

   356     if (m_loadTimer.isActive())

   357         return;

   358     prepareForLoad();

   359     m_loadTimer.startOneShot(0);

   360 }

   361 

   362 void HTMLMediaElement::scheduleNextSourceChild()

   363 {

   364     // Schedule the timer to try the next <source> element WITHOUT resetting state ala prepareForLoad.

   365     m_loadTimer.startOneShot(0);

   366 }

   367 

   368 void HTMLMediaElement::scheduleEvent(const AtomicString& eventName)

   369 {

   370     m_pendingEvents.append(Event::create(eventName, false, true));

   371     if (!m_asyncEventTimer.isActive())

   372         m_asyncEventTimer.startOneShot(0);

   373 }

   374 

   375 void HTMLMediaElement::asyncEventTimerFired(Timer<HTMLMediaElement>*)

   376 {

   377     Vector<RefPtr<Event> > pendingEvents;

   378     ExceptionCode ec = 0;

   379 

   380     m_pendingEvents.swap(pendingEvents);

   381     unsigned count = pendingEvents.size();

   382     for (unsigned ndx = 0; ndx < count; ++ndx) {

   383         if (pendingEvents[ndx]->type() == eventNames().canplayEvent) {

   384             m_dispatchingCanPlayEvent = true;

   385             dispatchEvent(pendingEvents[ndx].release(), ec);

   386             m_dispatchingCanPlayEvent = false;

   387         } else

   388             dispatchEvent(pendingEvents[ndx].release(), ec);

   389     }

   390 }

   391 

   392 void HTMLMediaElement::loadTimerFired(Timer<HTMLMediaElement>*)

   393 {

   394     if (m_loadState == LoadingFromSourceElement)

   395         loadNextSourceChild();

   396     else

   397         loadInternal();

   398 }

   399 

   400 static String serializeTimeOffset(float time)

   401 {

   402     String timeString = String::number(time);

   403     // FIXME serialize time offset values properly (format not specified yet)

   404     timeString.append("s");

   405     return timeString;

   406 }

   407 

   408 static float parseTimeOffset(const String& timeString, bool* ok = 0)

   409 {

   410     const UChar* characters = timeString.characters();

   411     unsigned length = timeString.length();

   412     

   413     if (length && characters[length - 1] == 's')

   414         length--;

   415     

   416     // FIXME parse time offset values (format not specified yet)

   417     float val = charactersToFloat(characters, length, ok);

   418     return val;

   419 }

   420 

   421 float HTMLMediaElement::getTimeOffsetAttribute(const QualifiedName& name, float valueOnError) const

   422 {

   423     bool ok;

   424     String timeString = getAttribute(name);

   425     float result = parseTimeOffset(timeString, &ok);

   426     if (ok)

   427         return result;

   428     return valueOnError;

   429 }

   430 

   431 void HTMLMediaElement::setTimeOffsetAttribute(const QualifiedName& name, float value)

   432 {

   433     setAttribute(name, serializeTimeOffset(value));

   434 }

   435 

   436 PassRefPtr<MediaError> HTMLMediaElement::error() const 

   437 {

   438     return m_error;

   439 }

   440 

   441 KURL HTMLMediaElement::src() const

   442 {

   443     return getNonEmptyURLAttribute(srcAttr);

   444 }

   445 

   446 void HTMLMediaElement::setSrc(const String& url)

   447 {

   448     setAttribute(srcAttr, url);

   449 }

   450 

   451 String HTMLMediaElement::currentSrc() const

   452 {

   453     return m_currentSrc;

   454 }

   455 

   456 HTMLMediaElement::NetworkState HTMLMediaElement::networkState() const

   457 {

   458     return m_networkState;

   459 }

   460 

   461 String HTMLMediaElement::canPlayType(const String& mimeType) const

   462 {

   463     MediaPlayer::SupportsType support = MediaPlayer::supportsType(ContentType(mimeType));

   464     String canPlay;

   465 

   466     // 4.8.10.3

   467     switch (support)

   468     {

   469         case MediaPlayer::IsNotSupported:

   470             canPlay = "";

   471             break;

   472         case MediaPlayer::MayBeSupported:

   473             canPlay = "maybe";

   474             break;

   475         case MediaPlayer::IsSupported:

   476             canPlay = "probably";

   477             break;

   478     }

   479     

   480     return canPlay;

   481 }

   482 

   483 void HTMLMediaElement::load(bool isUserGesture, ExceptionCode& ec)

   484 {

   485     if (m_restrictions & RequireUserGestureForLoadRestriction && !isUserGesture)

   486         ec = INVALID_STATE_ERR;

   487     else {

   488         m_loadInitiatedByUserGesture = isUserGesture;

   489         prepareForLoad();

   490         loadInternal();

   491     }

   492 }

   493 

   494 void HTMLMediaElement::prepareForLoad()

   495 {

   496     // Perform the cleanup required for the resource load algorithm to run.

   497     stopPeriodicTimers();

   498     m_loadTimer.stop();

   499     m_sentStalledEvent = false;

   500     m_haveFiredLoadedData = false;

   501     m_completelyLoaded = false;

   502 

   503     // 1 - Abort any already-running instance of the resource selection algorithm for this element.

   504     m_currentSourceNode = 0;

   505 

   506     // 2 - If there are any tasks from the media element's media element event task source in 

   507     // one of the task queues, then remove those tasks.

   508     cancelPendingEventsAndCallbacks();

   509 

   510     // 3 - If the media element's networkState is set to NETWORK_LOADING or NETWORK_IDLE, queue

   511     // a task to fire a simple event named abort at the media element.

   512     if (m_networkState == NETWORK_LOADING || m_networkState == NETWORK_IDLE)

   513         scheduleEvent(eventNames().abortEvent);

   514 

   515 #if !ENABLE(PLUGIN_PROXY_FOR_VIDEO)

   516     m_player = MediaPlayer::create(this);

   517 #else

   518     createMediaPlayerProxy();

   519 #endif

   520 

   521     // 4 - If the media element's networkState is not set to NETWORK_EMPTY, then run these substeps

   522     if (m_networkState != NETWORK_EMPTY) {

   523         m_networkState = NETWORK_EMPTY;

   524         m_readyState = HAVE_NOTHING;

   525         m_readyStateMaximum = HAVE_NOTHING;

   526         m_paused = true;

   527         m_seeking = false;

   528         scheduleEvent(eventNames().emptiedEvent);

   529     }

   530 

   531     // 5 - Set the playbackRate attribute to the value of the defaultPlaybackRate attribute.

   532     setPlaybackRate(defaultPlaybackRate());

   533 

   534     // 6 - Set the error attribute to null and the autoplaying flag to true.

   535     m_error = 0;

   536     m_autoplaying = true;

   537 

   538     m_playedTimeRanges = TimeRanges::create();

   539     m_lastSeekTime = 0;

   540     m_closedCaptionsVisible = false;

   541 

   542 }

   543 

   544 void HTMLMediaElement::loadInternal()

   545 {

   546     // If we can't start a load right away, start it later.

   547     Page* page = document()->page();

   548     if (page && !page->canStartMedia()) {

   549         if (m_isWaitingUntilMediaCanStart)

   550             return;

   551         document()->addMediaCanStartListener(this);

   552         m_isWaitingUntilMediaCanStart = true;

   553         return;

   554     }

   555 

   556     // Steps 1 - 6 were done in prepareForLoad

   557 

   558     // 7 - Invoke the media element's resource selection algorithm.

   559     selectMediaResource();

   560     m_processingLoad = false;

   561 }

   562 

   563 void HTMLMediaElement::selectMediaResource()

   564 {

   565     enum Mode { attribute, children };

   566     Mode mode = attribute;

   567 

   568     // 1 - Set the networkState to NETWORK_NO_SOURCE

   569     m_networkState = NETWORK_NO_SOURCE;

   570 

   571     // 2 - Asynchronously await a stable state.

   572 

   573     // 3 - ... the media element has neither a src attribute ...

   574     if (!hasAttribute(srcAttr)) {

   575         // ... nor a source element child: ...

   576         Node* node;

   577         for (node = firstChild(); node; node = node->nextSibling()) {

   578             if (node->hasTagName(sourceTag))

   579                 break;

   580         }

   581 

   582         if (!node) {

   583             m_loadState = WaitingForSource;

   584 

   585             // ... set the networkState to NETWORK_EMPTY, and abort these steps

   586             m_networkState = NETWORK_EMPTY;

   587             ASSERT(!m_delayingTheLoadEvent);

   588             return;

   589         }

   590 

   591         mode = children;

   592     }

   593 

   594     // 4

   595     m_delayingTheLoadEvent = true;

   596     m_networkState = NETWORK_LOADING;

   597 

   598     // 5

   599     scheduleEvent(eventNames().loadstartEvent);

   600 

   601     // 6 - If mode is attribute, then run these substeps

   602     if (mode == attribute) {

   603         // If the src attribute's value is the empty string ... jump down to the failed step below

   604         KURL mediaURL = getNonEmptyURLAttribute(srcAttr);

   605         if (mediaURL.isEmpty()) {

   606             noneSupported();

   607             return;

   608         }

   609 

   610         if (isSafeToLoadURL(mediaURL, Complain) && dispatchBeforeLoadEvent(mediaURL.string())) {

   611             ContentType contentType("");

   612             m_loadState = LoadingFromSrcAttr;

   613             loadResource(mediaURL, contentType);

   614         } else 

   615             noneSupported();

   616 

   617         return;

   618     }

   619 

   620     // Otherwise, the source elements will be used

   621     m_currentSourceNode = 0;

   622     loadNextSourceChild();

   623 }

   624 

   625 void HTMLMediaElement::loadNextSourceChild()

   626 {

   627     ContentType contentType("");

   628     KURL mediaURL = selectNextSourceChild(&contentType, Complain);

   629     if (!mediaURL.isValid()) {

   630         waitForSourceChange();

   631         return;

   632     }

   633 

   634 #if !ENABLE(PLUGIN_PROXY_FOR_VIDEO)

   635     // Recreate the media player for the new url

   636     m_player = MediaPlayer::create(this);

   637 #endif

   638 

   639     m_loadState = LoadingFromSourceElement;

   640     loadResource(mediaURL, contentType);

   641 }

   642 

   643 void HTMLMediaElement::loadResource(const KURL& initialURL, ContentType& contentType)

   644 {

   645     ASSERT(isSafeToLoadURL(initialURL, Complain));

   646 

   647     Frame* frame = document()->frame();

   648     if (!frame)

   649         return;

   650     FrameLoader* loader = frame->loader();

   651     if (!loader)

   652         return;

   653 

   654     KURL url(initialURL);

   655     if (!loader->willLoadMediaElementURL(url))

   656         return;

   657 

   658     // The resource fetch algorithm 

   659     m_networkState = NETWORK_LOADING;

   660 

   661     m_currentSrc = url;

   662 

   663     if (m_sendProgressEvents) 

   664         startProgressEventTimer();

   665 

   666     if (!autoplay())

   667         m_player->setPreload(m_preload);

   668     m_player->setPreservesPitch(m_webkitPreservesPitch);

   669     updateVolume();

   670 

   671     m_player->load(m_currentSrc, contentType);

   672 

   673     if (isVideo() && m_player->canLoadPoster()) {

   674         KURL posterUrl = poster();

   675         if (!posterUrl.isEmpty())

   676             m_player->setPoster(posterUrl);

   677     }

   678 

   679     if (renderer())

   680         renderer()->updateFromElement();

   681 }

   682 

   683 bool HTMLMediaElement::isSafeToLoadURL(const KURL& url, InvalidSourceAction actionIfInvalid)

   684 {

   685     if (!url.isValid())

   686         return false;

   687     

   688     Frame* frame = document()->frame();

   689     FrameLoader* loader = frame ? frame->loader() : 0;

   690 

   691     // don't allow remote to local urls, and check with the frame loader client.

   692     if (!loader || !SecurityOrigin::canLoad(url, String(), document())) {

   693         if (actionIfInvalid == Complain)

   694             FrameLoader::reportLocalLoadFailed(frame, url.string());

   695         return false;

   696     }

   697     

   698     return true;

   699 }

   700 

   701 void HTMLMediaElement::startProgressEventTimer()

   702 {

   703     if (m_progressEventTimer.isActive())

   704         return;

   705 

   706     m_previousProgressTime = WTF::currentTime();

   707     m_previousProgress = 0;

   708     // 350ms is not magic, it is in the spec!

   709     m_progressEventTimer.startRepeating(0.350);

   710 }

   711 

   712 void HTMLMediaElement::waitForSourceChange()

   713 {

   714     stopPeriodicTimers();

   715     m_loadState = WaitingForSource;

   716 

   717     // 6.17 - Waiting: Set the element's networkState attribute to the NETWORK_NO_SOURCE value

   718     m_networkState = NETWORK_NO_SOURCE;

   719 

   720     // 6.18 - Set the element's delaying-the-load-event flag to false. This stops delaying the load event.

   721     m_delayingTheLoadEvent = false;

   722 }

   723 

   724 void HTMLMediaElement::noneSupported()

   725 {

   726     stopPeriodicTimers();

   727     m_loadState = WaitingForSource;

   728     m_currentSourceNode = 0;

   729 

   730     // 5 - Reaching this step indicates that either the URL failed to resolve, or the media

   731     // resource failed to load. Set the error attribute to a new MediaError object whose

   732     // code attribute is set to MEDIA_ERR_SRC_NOT_SUPPORTED.

   733     m_error = MediaError::create(MediaError::MEDIA_ERR_SRC_NOT_SUPPORTED);

   734 

   735     // 6 - Set the element's networkState attribute to the NETWORK_NO_SOURCE value.

   736     m_networkState = NETWORK_NO_SOURCE;

   737 

   738     // 7 - Queue a task to fire a progress event called error at the media element, in

   739     // the context of the fetching process that was used to try to obtain the media

   740     // resource in the resource fetch algorithm.

   741     scheduleEvent(eventNames().errorEvent);

   742 

   743     // 8 - Set the element's delaying-the-load-event flag to false. This stops delaying the load event.

   744     m_delayingTheLoadEvent = false;

   745 

   746     // 9 -Abort these steps. Until the load() method is invoked, the element won't attempt to load another resource.

   747 

   748     updatePosterImage();

   749 

   750     if (renderer())

   751         renderer()->updateFromElement();

   752 }

   753 

   754 void HTMLMediaElement::mediaEngineError(PassRefPtr<MediaError> err)

   755 {

   756     // 1 - The user agent should cancel the fetching process.

   757     stopPeriodicTimers();

   758     m_loadState = WaitingForSource;

   759 

   760     // 2 - Set the error attribute to a new MediaError object whose code attribute is 

   761     // set to MEDIA_ERR_NETWORK/MEDIA_ERR_DECODE.

   762     m_error = err;

   763 

   764     // 3 - Queue a task to fire a progress event called error at the media element, in

   765     // the context of the fetching process started by this instance of this algorithm.

   766     scheduleEvent(eventNames().errorEvent);

   767 

   768     // 4 - Set the element's networkState attribute to the NETWORK_EMPTY value and queue a

   769     // task to fire a simple event called emptied at the element.

   770     m_networkState = NETWORK_EMPTY;

   771     scheduleEvent(eventNames().emptiedEvent);

   772 

   773     // 5 - Set the element's delaying-the-load-event flag to false. This stops delaying the load event.

   774     m_delayingTheLoadEvent = false;

   775 

   776     // 6 - Abort the overall resource selection algorithm.

   777     m_currentSourceNode = 0;

   778 }

   779 

   780 void HTMLMediaElement::cancelPendingEventsAndCallbacks()

   781 {

   782     m_pendingEvents.clear();

   783 

   784     for (Node* node = firstChild(); node; node = node->nextSibling()) {

   785         if (node->hasTagName(sourceTag))

   786             static_cast<HTMLSourceElement*>(node)->cancelPendingErrorEvent();

   787     }

   788 }

   789 

   790 Document* HTMLMediaElement::mediaPlayerOwningDocument()

   791 {

   792     Document* d = document();

   793     

   794     if (!d)

   795         d = ownerDocument();

   796     

   797     return d;

   798 }

   799 

   800 void HTMLMediaElement::mediaPlayerNetworkStateChanged(MediaPlayer*)

   801 {

   802     beginProcessingMediaPlayerCallback();

   803     setNetworkState(m_player->networkState());

   804     endProcessingMediaPlayerCallback();

   805 }

   806 

   807 void HTMLMediaElement::setNetworkState(MediaPlayer::NetworkState state)

   808 {

   809     if (state == MediaPlayer::Empty) {

   810         // just update the cached state and leave, we can't do anything 

   811         m_networkState = NETWORK_EMPTY;

   812         return;

   813     }

   814 

   815     if (state == MediaPlayer::FormatError || state == MediaPlayer::NetworkError || state == MediaPlayer::DecodeError) {

   816         stopPeriodicTimers();

   817 

   818         // If we failed while trying to load a <source> element, the movie was never parsed, and there are more

   819         // <source> children, schedule the next one

   820         if (m_readyState < HAVE_METADATA && m_loadState == LoadingFromSourceElement) {

   821             m_currentSourceNode->scheduleErrorEvent();

   822             if (havePotentialSourceChild())

   823                 scheduleNextSourceChild();

   824             else

   825                 waitForSourceChange();

   826 

   827             return;

   828         }

   829 

   830         if (state == MediaPlayer::NetworkError)

   831             mediaEngineError(MediaError::create(MediaError::MEDIA_ERR_NETWORK));

   832         else if (state == MediaPlayer::DecodeError)

   833             mediaEngineError(MediaError::create(MediaError::MEDIA_ERR_DECODE));

   834         else if (state == MediaPlayer::FormatError && m_loadState == LoadingFromSrcAttr)

   835             noneSupported();

   836 

   837         updatePosterImage();

   838         return;

   839     }

   840 

   841     if (state == MediaPlayer::Idle) {

   842         if (m_networkState > NETWORK_IDLE) {

   843             m_progressEventTimer.stop();

   844             scheduleEvent(eventNames().suspendEvent);

   845         }

   846         m_networkState = NETWORK_IDLE;

   847     }

   848 

   849     if (state == MediaPlayer::Loading) {

   850         if (m_networkState < NETWORK_LOADING || m_networkState == NETWORK_NO_SOURCE)

   851             startProgressEventTimer();

   852         m_networkState = NETWORK_LOADING;

   853     }

   854 

   855     if (state == MediaPlayer::Loaded) {

   856         if (m_networkState != NETWORK_IDLE) {

   857             m_progressEventTimer.stop();

   858 

   859             // Schedule one last progress event so we guarantee that at least one is fired

   860             // for files that load very quickly.

   861             scheduleEvent(eventNames().progressEvent);

   862         }

   863         m_networkState = NETWORK_IDLE;

   864         m_completelyLoaded = true;

   865     }

   866 }

   867 

   868 void HTMLMediaElement::mediaPlayerReadyStateChanged(MediaPlayer*)

   869 {

   870     beginProcessingMediaPlayerCallback();

   871 

   872     setReadyState(m_player->readyState());

   873 

   874     endProcessingMediaPlayerCallback();

   875 }

   876 

   877 void HTMLMediaElement::setReadyState(MediaPlayer::ReadyState state)

   878 {

   879     // Set "wasPotentiallyPlaying" BEFORE updating m_readyState, potentiallyPlaying() uses it

   880     bool wasPotentiallyPlaying = potentiallyPlaying();

   881 

   882     ReadyState oldState = m_readyState;

   883     m_readyState = static_cast<ReadyState>(state);

   884 

   885     if (m_readyState == oldState)

   886         return;

   887     

   888     if (oldState > m_readyStateMaximum)

   889         m_readyStateMaximum = oldState;

   890 

   891     if (m_networkState == NETWORK_EMPTY)

   892         return;

   893 

   894     if (m_seeking) {

   895         // 4.8.10.10, step 8

   896         if (wasPotentiallyPlaying && m_readyState < HAVE_FUTURE_DATA)

   897             scheduleEvent(eventNames().waitingEvent);

   898 

   899         // 4.8.10.10, step 9

   900         if (m_readyState < HAVE_CURRENT_DATA) {

   901             if (oldState >= HAVE_CURRENT_DATA)

   902                 scheduleEvent(eventNames().seekingEvent);

   903         } else {

   904             // 4.8.10.10 step 12 & 13.

   905             finishSeek();

   906         }

   907 

   908     } else {

   909         if (wasPotentiallyPlaying && m_readyState < HAVE_FUTURE_DATA) {

   910             // 4.8.10.9

   911             scheduleTimeupdateEvent(false);

   912             scheduleEvent(eventNames().waitingEvent);

   913         }

   914     }

   915 

   916     if (m_readyState >= HAVE_METADATA && oldState < HAVE_METADATA) {

   917         scheduleEvent(eventNames().durationchangeEvent);

   918         scheduleEvent(eventNames().loadedmetadataEvent);

   919 

   920 #if !ENABLE(PLUGIN_PROXY_FOR_VIDEO)

   921         if (renderer() && renderer()->isVideo()) {

   922             toRenderVideo(renderer())->videoSizeChanged();

   923         }

   924 #endif        

   925         m_delayingTheLoadEvent = false;

   926         m_player->seek(0);

   927     }

   928 

   929     bool shouldUpdatePosterImage = false;

   930 

   931     // 4.8.10.7 says loadeddata is sent only when the new state *is* HAVE_CURRENT_DATA: "If the

   932     // previous ready state was HAVE_METADATA and the new ready state is HAVE_CURRENT_DATA", 

   933     // but the event table at the end of the spec says it is sent when: "readyState newly 

   934     // increased to HAVE_CURRENT_DATA  or greater for the first time"

   935     // We go with the later because it seems useful to count on getting this event

   936     if (m_readyState >= HAVE_CURRENT_DATA && oldState < HAVE_CURRENT_DATA && !m_haveFiredLoadedData) {

   937         m_haveFiredLoadedData = true;

   938         shouldUpdatePosterImage = true;

   939         scheduleEvent(eventNames().loadeddataEvent);

   940     }

   941 

   942     bool isPotentiallyPlaying = potentiallyPlaying();

   943     if (m_readyState == HAVE_FUTURE_DATA && oldState <= HAVE_CURRENT_DATA) {

   944         scheduleEvent(eventNames().canplayEvent);

   945         if (isPotentiallyPlaying)

   946             scheduleEvent(eventNames().playingEvent);

   947         shouldUpdatePosterImage = true;

   948     }

   949 

   950     if (m_readyState == HAVE_ENOUGH_DATA && oldState < HAVE_ENOUGH_DATA) {

   951         if (oldState <= HAVE_CURRENT_DATA)

   952             scheduleEvent(eventNames().canplayEvent);

   953 

   954         scheduleEvent(eventNames().canplaythroughEvent);

   955 

   956         if (isPotentiallyPlaying && oldState <= HAVE_CURRENT_DATA)

   957             scheduleEvent(eventNames().playingEvent);

   958 

   959         if (m_autoplaying && m_paused && autoplay()) {

   960             m_paused = false;

   961             scheduleEvent(eventNames().playEvent);

   962             scheduleEvent(eventNames().playingEvent);

   963         }

   964 

   965         shouldUpdatePosterImage = true;

   966     }

   967 

   968     if (shouldUpdatePosterImage)

   969         updatePosterImage();

   970 

   971     updatePlayState();

   972 }

   973 

   974 void HTMLMediaElement::progressEventTimerFired(Timer<HTMLMediaElement>*)

   975 {

   976     ASSERT(m_player);

   977     if (m_networkState != NETWORK_LOADING)

   978         return;

   979 

   980     unsigned progress = m_player->bytesLoaded();

   981     double time = WTF::currentTime();

   982     double timedelta = time - m_previousProgressTime;

   983 

   984     if (progress == m_previousProgress) {

   985         if (timedelta > 3.0 && !m_sentStalledEvent) {

   986             scheduleEvent(eventNames().stalledEvent);

   987             m_sentStalledEvent = true;

   988         }

   989     } else {

   990         scheduleEvent(eventNames().progressEvent);

   991         m_previousProgress = progress;

   992         m_previousProgressTime = time;

   993         m_sentStalledEvent = false;

   994         if (renderer())

   995             renderer()->updateFromElement();

   996     }

   997 }

   998 

   999 void HTMLMediaElement::rewind(float timeDelta)

  1000 {

  1001     ExceptionCode e;

  1002     setCurrentTime(max(currentTime() - timeDelta, minTimeSeekable()), e);

  1003 }

  1004 

  1005 void HTMLMediaElement::returnToRealtime()

  1006 {

  1007     ExceptionCode e;

  1008     setCurrentTime(maxTimeSeekable(), e);

  1009 }  

  1010 

  1011 void HTMLMediaElement::addPlayedRange(float start, float end)

  1012 {

  1013     if (!m_playedTimeRanges)

  1014         m_playedTimeRanges = TimeRanges::create();

  1015     m_playedTimeRanges->add(start, end);

  1016 }  

  1017 

  1018 bool HTMLMediaElement::supportsSave() const

  1019 {

  1020     return m_player ? m_player->supportsSave() : false;

  1021 }

  1022     

  1023 void HTMLMediaElement::seek(float time, ExceptionCode& ec)

  1024 {

  1025     // 4.8.9.9 Seeking

  1026 

  1027     // 1 - If the media element's readyState is HAVE_NOTHING, then raise an INVALID_STATE_ERR exception.

  1028     if (m_readyState == HAVE_NOTHING || !m_player) {

  1029         ec = INVALID_STATE_ERR;

  1030         return;

  1031     }

  1032 

  1033     // Get the current time before setting m_seeking, m_lastSeekTime is returned once it is set.

  1034     float now = currentTime();

  1035 

  1036     // 3 - Set the seeking IDL attribute to true.

  1037     // The flag will be cleared when the engine tells is the time has actually changed

  1038     m_seeking = true;

  1039 

  1040     // 4 - Queue a task to fire a simple event named timeupdate at the element.

  1041     scheduleTimeupdateEvent(false);

  1042 

  1043     // 6 - If the new playback position is later than the end of the media resource, then let it be the end 

  1044     // of the media resource instead.

  1045     time = min(time, duration());

  1046 

  1047     // 7 - If the new playback position is less than the earliest possible position, let it be that position instead.

  1048     float earliestTime = m_player->startTime();

  1049     time = max(time, earliestTime);

  1050 

  1051     // 8 - If the (possibly now changed) new playback position is not in one of the ranges given in the 

  1052     // seekable attribute, then let it be the position in one of the ranges given in the seekable attribute 

  1053     // that is the nearest to the new playback position. ... If there are no ranges given in the seekable

  1054     // attribute then set the seeking IDL attribute to false and abort these steps.

  1055     RefPtr<TimeRanges> seekableRanges = seekable();

  1056     if (!seekableRanges->length() || time == now) {

  1057         m_seeking = false;

  1058         return;

  1059     }

  1060     time = seekableRanges->nearest(time);

  1061 

  1062     if (m_playing) {

  1063         if (m_lastSeekTime < now)

  1064             addPlayedRange(m_lastSeekTime, now);

  1065     }

  1066     m_lastSeekTime = time;

  1067     m_sentEndEvent = false;

  1068 

  1069     // 9 - Set the current playback position to the given new playback position

  1070     m_player->seek(time);

  1071 

  1072     // 10-15 are handled, if necessary, when the engine signals a readystate change.

  1073 

  1074 }

  1075 

  1076 void HTMLMediaElement::finishSeek()

  1077 {

  1078     // 4.8.10.10 Seeking step 12

  1079     m_seeking = false;

  1080 

  1081     // 4.8.10.10 Seeking step 13

  1082     scheduleEvent(eventNames().seekedEvent);

  1083 }

  1084 

  1085 HTMLMediaElement::ReadyState HTMLMediaElement::readyState() const

  1086 {

  1087     return m_readyState;

  1088 }

  1089 

  1090 MediaPlayer::MovieLoadType HTMLMediaElement::movieLoadType() const

  1091 {

  1092     return m_player ? m_player->movieLoadType() : MediaPlayer::Unknown;

  1093 }

  1094 

  1095 bool HTMLMediaElement::hasAudio() const

  1096 {

  1097     return m_player ? m_player->hasAudio() : false;

  1098 }

  1099 

  1100 bool HTMLMediaElement::seeking() const

  1101 {

  1102     return m_seeking;

  1103 }

  1104 

  1105 // playback state

  1106 float HTMLMediaElement::currentTime() const

  1107 {

  1108     if (!m_player)

  1109         return 0;

  1110     if (m_seeking)

  1111         return m_lastSeekTime;

  1112     return m_player->currentTime();

  1113 }

  1114 

  1115 void HTMLMediaElement::setCurrentTime(float time, ExceptionCode& ec)

  1116 {

  1117     seek(time, ec);

  1118 }

  1119 

  1120 float HTMLMediaElement::startTime() const

  1121 {

  1122     if (!m_player)

  1123         return 0;

  1124     return m_player->startTime();

  1125 }

  1126 

  1127 float HTMLMediaElement::duration() const

  1128 {

  1129     if (m_player && m_readyState >= HAVE_METADATA)

  1130         return m_player->duration();

  1131 

  1132     return numeric_limits<float>::quiet_NaN();

  1133 }

  1134 

  1135 bool HTMLMediaElement::paused() const